智朋的个人博客

/*
class 外部类名{
 修饰符 class 内部类名{
 
 }
}
*/

class Outer {
 //此处的Inner就是所说的内部类
    public class Inner {
        
    }
}

public class Test1Inner {
    public static void main(String[] args) {
     //此处编译器报错
        Inner i = new Inner();
    }
}

class Outer {
    private int a = 10;
    //内部类
    class Inner {
        int num = 10;

        public void show(){
            System.out.println("Inner..show");
        }
    }
}

Inner i = new Inner();

public class Test1Inner {
    public static void main(String[] args) {
        Inner i = new Inner();
    }
}

class Outer {
    private int a = 10;
    //内部类
    class Inner {

    }
}

class Outer2{
    class Inner{
        
    }
}

public class Test1Inner {
    public static void main(String[] args) {
        //创建内部类的格式
        //外部类名.内部类类名 对象名 = new 外部类对象().new 内部类对象;
        Outer.Inner i = new Outer().new Inner();
    }
}

class Outer {
    private int a = 10;
    //内部类
    class Inner {

    }
}

public class Test1Inner {  
    public static void main(String[] args) {  
        //创建内部类的格式  
        //外部类名.内部类类名 对象名 = new 外部类对象().new 内部类对象;  
        Outer.Inner i = new Outer().new Inner();  
        //访问内部类变量  
        System.out.println(i.num);  
        //访问内部类方法  
        i.show();  
    }  
  
}  
  
class Outer {  
    private int a = 10;  
    //内部类  
    class Inner {  
        int num = 10;  
        public void show(){  
            System.out.println("Inner...show");  
        }  
    }  
}

public class Test1Inner {  
    public static void main(String[] args) {  
        //创建内部类的格式  
        //外部类名.内部类类名 对象名 = new 外部类对象().new 内部类对象;  
        Outer.Inner i = new Outer().new Inner();  
        //访问内部类变量  
        System.out.println(i.num);  
        //访问内部类方法  
        i.show();  
    }  
  
}  
  
class Outer { 
 //外部类中私有的成员变量
    private int a = 10;  
    //内部类  
    class Inner {  
        int num = 10;  
        public void show(){  
            System.out.println("Inner...show");
            //内部类可以直接访问外部类的成员变量（包括私有的成员变量）  
            System.out.println("外部类中的成员变量" + a);  
        }  
    }  
}

10
Inner...show
外部类中的成员变量10

//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Outer.Inner oi = new Outer().new Inner();

public class Test2Innerclass {  
    public static void main(String[] args) {
     //此处编译错误  
        Outer.Inner oi = new Outer().new Inner();  
    }  
}  
  
class Outer {  
    //私有成员内部类  
    private class Inner {  
        public void show(){  
            System.out.println("inner..show");  
        }  
    }  
}

public class Test2Innerclass {  
    public static void main(String[] args) {  
        Outer outer = new Outer();  
        //调用外部类中的方法，利用类中的方法来间接访问内部类  
        outer.method();  
    }  
}  
  
class Outer {  
    //私有成员内部类  
    private class Inner {  
        public void show(){  
            System.out.println("inner..show");  
        }  
    }  
  
    public void method(){  
        //因为和Inner类都属于Outer类，所以可以直接这样创建  
        Inner i = new Inner();
        //访问类中的方法  
        i.show();  
    }  
}

public class Test3Innerclass {  
    public static void main(String[] args) {  
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();  
        Outer.Inner oi = new Outer.Inner();  
        oi.show();  
    }  
}  
  
class Outer {  
    //静态成员内部类  
    static class Inner {  
        public void show(){  
            System.out.println("inner..show");  
        }  
    }  
}

Outer.Inner oi = new Outer().new Inner(); //错误，这是没有加static修饰符时的方式
Outer.Inner oi = new Outer.Inner();       //正确

public class Test3Innerclass {  
    public static void main(String[] args) {  
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();  
        Outer.Inner oi = new Outer.Inner();  
        //类名一路调用即可
        Outer.Inner.method();  
    }  
}  
  
class Outer {  
    //静态成员内部类  
    static class Inner {  
        public static void method(){  
            System.out.println("inner..method");  
        }  
    }  
}

//类名一路调用即可，都是Static的，无需创建对象，直接类名调用
Outer.Inner.method(); 

外部类名.内部类名 对象名 = new 外部类名.内部类名(); 

外部类名.内部类名.方法名();

public class Test4Innerclass {  
    public static void main(String[] args) {  
        Outer o = new Outer();  
        o.method();  
    }  
}  
  
class Outer {  
  
    public void method(){  
  
        //写在method当中的局部内部类  
        class Inner {  
            public void show(){  
                System.out.println("show...");  
            }  
        }  
  
        //方法内部可以访问Inner类  
        Inner inner = new Inner();  
        inner.show();  
    }  
}

public class Test4Innerclass {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

class Outer {
    // 类中的成员变量
    int a = 10;

    public void method(){
        // 方法中的局部变量
        int b = 20;

        //写在method当中的局部内部类
        class Inner {
            public void show(){
                System.out.println("show...");
                // 可以访问（嵌在里边的可以访问外边的）
                System.out.println(a);
                // 可以访问方法中的局部变量
                System.out.println(b);
            }
        }

        //方法内部可以访问Inner类
        Inner inner = new Inner();
        inner.show();
    }
}

/*
new 类名或接口名(){
 重写方法;
}
*/

new Inter(){
    @Override
    public void method(){}
} 

public class Test5Innerclass {
    public static void main(String[] args) {
        InterImpl ii = new InterImpl();
        ii.show();
    }
}

interface Inner{
    void show();
}

class InterImpl implements Inner{
    @Override
    public void show() {
        System.out.println("InterImpl 重写的show方法");
    }
}

new Inner(){
 //『实现接口的类』中需要重写的方法
}.show();

new Inner(){}; --> 相当于创建了一个实现了接口的实现类对象
new Inner(){}.show(); --> 实现类对象调用方法

public class Test5Innerclass {
    public static void main(String[] args) {

        //匿名内部类
        new Inner(){
            @Override
            public void show1() {
                System.out.println("匿名内部类中的show1方法");
            }

            @Override
            public void show2() {
                System.out.println("匿名内部类中的show2方法");
            }
  //此处只能调用一次方法，就相当于"对象.方法"，而不能"对象.方法1.方法2"
        }.show1();
    }
}

interface Inner{
    void show1();
    void show2();
}

public class Test5Innerclass {  
    public static void main(String[] args) {  
  
        //Inner i 接口的引用；new Inner(){} 实现类对象 --> 父类的引用指向了一个子类的对象（多态）  
        Inner i = new Inner(){  
            @Override  
            public void show1() {  
                System.out.println("匿名内部类中的show1方法");  
            }  
  
            @Override  
            public void show2() {  
                System.out.println("匿名内部类中的show2方法");  
            }  
        };  
  
        i.show1();  
        i.show2();  
    }  
}  
  
interface Inner{  
    void show1();  
    void show2();  
}

public class TestSwimming {  
    public static void main(String[] args) {  
  
        //调用方法(参数要求为实现类对象，这里我们使用匿名内部类的方式)  
        goSwimming(new Swimming(){  
            @Override  
            public void swim() {  
                System.out.println("GoGoGo!");  
            }  
        });  
    }  
  
    //实际参数为接口的方法  
    public static void goSwimming(Swimming swimming){  
        swimming.swim();  
    }  
}  
  
interface Swimming {  
    void swim();  
}

public class TestSwimming {
    public static void main(String[] args) {

        //1、使用匿名内部类的方式
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });

        //2、使用Lambda表达式，此处可以理解为是对匿名内部类的优化
        goSwimming(() -> System.out.println("铁汁, 我们去游泳吧"));
    }

    //使用接口的方法
    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }
}

interface Swimming {
    void swim();
}

(形式参数) -> {代码块}

public class StringHandlerDemo {  
  
    public static void main(String[] args) {  
        // 匿名内部类的实现方式  
        useStringHandler(new StringHandler() {  
            @Override  
            public void printMessage(String msg) {  
                System.out.println("我是匿名内部类" + msg);  
            }  
        });  
  
        // Lambda实现方式  
        useStringHandler((String msg)->{System.out.println("我是Lambda表达式" + msg);});  
        useStringHandler( (msg) -> System.out.println("我是Lambda表达式" + msg));  
        useStringHandler( msg -> System.out.println("我是Lambda表达式" + msg));  
    }  
  
    public static void useStringHandler(StringHandler stringHandler){  
        stringHandler.printMessage("coffeelize");  
    }  
}  
  
interface StringHandler {  
    //带参数无返回值  
    void printMessage(String msg);  
}

public class RandomNumHandlerDemo {  
  
    public static void main(String[] args) {  
        //匿名内部类实现方式  
        useRandomNumHandler(new RandomNumHandler() {  
            @Override  
            public int getNumber() {  
                Random r = new Random();  
                //产生一个1-10的随机数  
                int num = r.nextInt(10) + 1;  
                return num;  
            }  
        });  
  
        //Lambda表达式实现方式  
        useRandomNumHandler( () -> {  
                Random r = new Random();  
                int num = r.nextInt(10) + 1;  
                // 注意: 如果lambda所操作的接口中的方法, 有返回值, 一定要通过return语句，否则会出现编译错误  
                return num;  
        } );  
    }  
  
    public static void useRandomNumHandler(RandomNumHandler randomNumHandler){  
        int result = randomNumHandler.getNumber();  
        System.out.println(result);  
    }  
}  
  
interface RandomNumHandler {  
    //无参数有返回值  
    int getNumber();  
}

public class CalculatorDemo {  
  
    public static void main(String[] args) {  
        //匿名内部类的实现方式  
        useCalculator(new Calculator() {  
            @Override  
            public int calc(int a, int b) {  
                return a + b;  
            }  
        });  
  
        //Lambda表达式实现方式  
        useCalculator((int a, int b)->{  
            return a + b;  
        });  
  
        useCalculator( (a,b) ->  
             a + b  
        );  
    }  
  
    public static void useCalculator(Calculator calculator){  
        int result = calculator.calc(10,20);  
        System.out.println(result);  
    }  
}  
  
interface Calculator {  
    //带参数，带返回值  
    int calc(int a, int b);  
}

//Lambda表达式实现方式  
useCalculator((int a, int b)->{  
 return a + b;  
});  

useCalculator( (a,b) ->  
  a + b  
); 

# 关闭防火墙
systemctl stop firewalld
# 禁止开机启动防火墙
systemctl disable firewalld
# 查看防火墙状态
systemctl status firewalld

systemctl start docker  # 启动docker服务

systemctl stop docker  # 停止docker服务

systemctl restart docker  # 重启docker服务

systemctl status docker
//或者
docker -v

//查看docker命令及简介
docker --help
//查看具体的某一命令，比如这里详细查看images命令的功能
docker images --help

//这里官方示例中没有指定版本，那么默认就是最新版
docker pull nginx

docker images

docker save --help

docker save -o [保存的目标文件名称] [镜像名称]

docker save -o nginx.tar nginx:latest

docker rmi nginx:latest

docker load -i nginx.tar

docker run --name containerName -p 80:80 -d nginx

192.168.119.128:80

//命令格式
docker logs [OPTIONS] CONTAINER

//docker logs 容器名
docker logs mn

//持续跟踪日志，通过Ctrl+C可以停止跟踪
docker logs -f mn

docker exec -it mn bash

cd /usr/share/nginx/html

exit

docker stop mn

//查看运行中的docker
docker ps
//查看所有容器（包括停止的）
docker ps -a

docker start mn

//停掉容器之后删除容器 或者 强制删除运行中的程序
docker rm -f mn

docker volume [COMMAND]

docker volume create html

docker volume ls

docker volume inspect html

docker run --name mn -v html:/usr/share/nginx/html -p 80:80 -d nginx

docker run --name mn -v html:/usr/share/nginx/html -p 80:80 -d nginx

cd /
cd tmp/

//rz或FinalShell上传mysql.tar

docker load -i mysql.tar
//查看镜像是否导入，mysql的版本为5.7.25
docker images

//-p表示多级目录创建
mkdir -p /tmp/mysql/data

//-p表示多级目录创建
mkdir -p /tmp/mysql/conf

//rz或FinalShell上传hmy.cnf

cd /tmp/
mkdir docker-demo

cd docker-demo

docker build -t javaweb:1.0 .

docker run --name web -p 8090:8090 -d javaweb:1.0

http://192.168.119.128:8090/hello/count

version: "3.8"
services:
  mysql:
    image: mysql:5.7.25
    environment:
     MYSQL_ROOT_PASSWORD: 123 
    volumes:
     - "/tmp/mysql/data:/var/lib/mysql"
     - "/tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf"
  web:
    build: .
    ports:
     - "8090:8090"

# 安装
curl -L https://github.com/docker/compose/releases/download/1.23.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

# 修改权限
chmod +x /usr/local/bin/docker-compose

# 补全命令
curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose

echo "199.232.68.133 raw.githubusercontent.com" >> /etc/hosts

version: "3.2"

services:
  nacos:
    image: nacos/nacos-server
    environment:
      MODE: standalone
    ports:
      - "8848:8848"
  mysql:
    image: mysql:5.7.25
    environment:
      MYSQL_ROOT_PASSWORD: 123
    volumes:
      - "$PWD/mysql/data:/var/lib/mysql"
      - "$PWD/mysql/conf:/etc/mysql/conf.d/"
  userservice:
    build: ./user-service
  orderservice:
    build: ./order-service
  gateway:
    build: ./gateway
    ports:
      - "10010:10010"

FROM java:8-alpine
COPY ./app.jar /tmp/app.jar
ENTRYPOINT java -jar /tmp/app.jar

cd /
cd /tmp/

//上传cloud-demo文件夹

cd cloud-demo/
docker-compose up -d

docker images
docker ps

docker-compose logs -f

//退出日志
Ctrl+C

//重启微服务(微服务启动前Nacos已经启动完成)
docker-compose restart gateway userservice orderservice

http://192.168.119.128:10010/user/2?authorization=admin
http://192.168.119.128:10010/order/102?authorization=admin

//删除通过docker-compose部署的容器，同时删除镜像
docker-compose down --rmi all

192.168.119.128:8080

public class JunitDemo1 {
    @Test
    public void add() {
        System.out.println(2 / 0);
        int a = 10;
        int b = 20;
        int sum = a + b;
        System.out.println(sum);
    }
}

public class Log4JTest01 {
    //方式1：使用log4j的api来获取日志的对象
    //弊端：如果以后我们更换日志的实现类，那么下面的代码就需要跟着改
    //不推荐使用
    //private static final Logger LOGGER = Logger.getLogger(Log4JTest01.class);

    //方式2：使用slf4j里面的api来获取日志的对象
    //好处：如果以后我们更换日志的实现类，那么下面的代码不需要跟着修改
    //推荐使用（在代码中获取日志的对象）
    private static final Logger LOGGER = LoggerFactory.getLogger(Log4JTest01.class);

    public static void main(String[] args) {
        //1.导入jar包
        //2.编写配置文件
        //3.在代码中获取日志的对象
        //4.按照日志级别设置日志信息
        LOGGER.debug("debug级别的日志");
        LOGGER.info("info级别的日志");
        LOGGER.warn("warn级别的日志");
        LOGGER.error("error级别的日志");
    }
}

@WebServlet(urlPatterns = "/servlet/loginservlet")
public class LoginServlet implements HttpServlet{

    //获取日志的对象
    private static final Logger LOGGER = LoggerFactory.getLogger(LoginServlet.class);

    @Override
    public void service(HttpRequest httpRequest, HttpResponse httpResponse) {
       //处理
        System.out.println("LoginServlet处理了登录请求");

        LOGGER.info("现在已经处理了登录请求，准备给浏览器响应");

       //响应
        httpResponse.setContentTpye("text/html;charset=UTF-8");
        httpResponse.write("登录成功");
    }
}

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void study(){
        System.out.println("学生在学习");
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.Class类中的静态方法forName("全类名")
        //全类名:包名 + 类名
        Class clazz = Class.forName("com.itheima.myreflect2.Student");
        System.out.println(clazz);

        //2.通过class属性来获取
        Class clazz2 = Student.class;
        System.out.println(clazz2);

        //3.利用对象的getClass方法来获取class对象
        //getClass方法是定义在Object类中.
        Student s = new Student();
        Class clazz3 = s.getClass();
        System.out.println(clazz3);

  //class对象是唯一的
        System.out.println(clazz == clazz2);
        System.out.println(clazz2 == clazz3);
    }
}

public class Student {
    private String name;
    private int age;

    //私有的有参构造方法
    private Student(String name) {
        System.out.println("name的值为:" + name);
        System.out.println("private...Student...有参构造方法");
    }

    //公共的无参构造方法
    public Student() {
        System.out.println("public...Student...无参构造方法");
    }

    //公共的有参构造方法
    public Student(String name, int age) {
        System.out.println("name的值为:" + name + "age的值为:" + age);
        System.out.println("public...Student...有参构造方法");
    }
}

public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //method1();
        //method2();
        //method3();
        //method4();
    }

    private static void method4() throws ClassNotFoundException, NoSuchMethodException {
        //返回单个构造方法对象
        //1.获取Class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");
        //获取单个构造方法对象
        Constructor constructor = clazz.getDeclaredConstructor(String.class);
        System.out.println(constructor);
    }

    private static void method3() throws ClassNotFoundException, NoSuchMethodException {
        //返回单个公共构造方法对象
        //1.获取Class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");
        //小括号中,一定要跟构造方法的形参保持一致
        //获取单个公共构造方法对象
        Constructor constructor1 = clazz.getConstructor();
        System.out.println(constructor1);
        //这里获取有参构造方法
        Constructor constructor2 = clazz.getConstructor(String.class, int.class);
        System.out.println(constructor2);

        //因为Student类中,没有只有一个int的构造,所以这里会报错.
        Constructor constructor3 = clazz.getConstructor(int.class);
        System.out.println(constructor3);
    }

    private static void method2() throws ClassNotFoundException {
        //返回所有构造方法对象的数组
        //1.获取Class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");
  //2.获取所有构造方法对象的数组
        Constructor[] constructors = clazz.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
    }

    private static void method1() throws ClassNotFoundException {
        //返回所有公共构造方法对象的数组
        //1.获取Class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");
        //2.获取所有公共构造方法对象的数组
        Constructor[] constructors = clazz.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
    }
}

// Student类同上一个示例,这里就不在重复提供了
public class ReflectDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //T newInstance(Object... initargs)：根据指定的构造方法创建对象
        //method1();
        //method2();
        //method3();
        //method4();

    }
    private static void method1() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");

        //2.获取构造方法对象
        Constructor constructor = clazz.getConstructor(String.class, int.class);

        //3.利用newInstance创建Student的对象
        Student student = (Student) constructor.newInstance("zhangsan", 23);

        System.out.println(student);
    }
    
    private static void method2() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");

        //2.获取构造方法对象
        Constructor constructor = clazz.getConstructor();

        //3.利用空参来创建Student的对象
        Student student = (Student) constructor.newInstance();

        System.out.println(student);
    }

    private static void method3() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        //method2的简写格式
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");

        //2.在Class类中,有一个newInstance方法,可以利用空参直接创建一个对象
        Student student = (Student) clazz.newInstance();//这个方法现在已经过时了,了解一下

        System.out.println(student);
    }

	private static void method4() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        //获取一个私有的构造方法并创建对象
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");

        //2.获取一个私有化的构造方法.
        Constructor constructor = clazz.getDeclaredConstructor(String.class);

        //被private修饰的成员,不能直接使用的
        //如果用反射强行获取并使用,需要临时取消访问检查
        constructor.setAccessible(true);

        //3.直接创建对象
        Student student = (Student) constructor.newInstance("zhangsan");

        System.out.println(student);
    }

}