10.14上课总结

一. 匿名对象
定义: 没有名字的对象。
意义: 节省代码，并且很多情况下是针对某个方法只需要调用一次的情况下。
匿名对象可以调用方法，也可以给成员变量赋值。 同时也可以作为方法的参数进行传递。

主要的作用就是节省代码量，使代码结构更优雅。

课堂练习：

public class Demo1{
    
    public static void main(String[] args){
        /*
        Person person = new Person();
        person.name="diffo";
        person.age = 20;
        person.speak();
        */
        //new Person("diffo",20).speak();
        
        Person person = new Person();
        person.initPerson(person);
        person.speak();
        
        initPerson(new Person()).speak();
        
    }
    
    //定义的名称，是针对person对象初始化的。
    static Person initPerson(Person person){
        person.name="diffo";
        person.age = 22;
        return person;
    }
    
}

class Person{
    
    String name;
    int age;
    
    Person(){
        
    }
    
    Person(String nameParm,int ageParm){
        name = nameParm;
        age = ageParm;
    }
    
    void initPerson(Person person){
        person.name="diffo";
        person.age = 22;
    }
    
    void speak(){
        System.out.println("speak!: "+name+" . "+age);
    }
    
}

二. 封装
1.概念: 隐藏对象的属性和细节，仅对外提供公共的方法进行访问。
2.private
a. 当类的成员变量使用private 修饰符修饰，那么就不可以直接访问到该成员变量.
b. 当使用private 修饰的成员变量或者成员方法，仅能在本类中使用

c. private 对于main 方法的修饰，也是可以产生作用的.

课堂练习：

public class DemoPrivate{   
    public static void main(String[] args){
        Person person =new Person();
        person.name = "diffo";
        person.setAge(20);
        person.eat();//error
        person.action();
    }
    
}

class Person{
    String name;
    private int age;
    
    void setAge(int ageParm){
        if(ageParm>0 && ageParm<150){
            age = ageParm;
        }
    }
    
    void eat(){
       System.out.println("eat");    
    }
    
    void action(){
        eat();
        speak();
    }
    
    void speak(){
        System.out.println("speak!: "+name+" . "+age);
    }
}

javaBean:
是这样一类的类:
他的所有成员变量都使用private 进行修饰，并且对外提供可访问的设置值和获取值的set,get方法。不同的应用场景，可能命名
不同，数据库的应用中称为POJO类.

课堂练习：

//java bean
class Person{
    private String name;
    private int age;
    
    void setName(String nameParm){
        name = nameParm;
    }
    
    String getName(){
        return name;
    }
    
    void setAge(int ageParm){
        age = ageParm;
    }
    
    int getAge(){
        return age;
    }
    
    void speak(){
        System.out.println(name+" . "+age);
    }
    
    public static void main(String[] args){
        Person person = new Person();
        person.setName("diffo");
        person.setAge(30);
        person.speak();
    }
}

class DemoBean{
    
        public static void main(String[] args){
        Person person = new Person();
        person.setName("diffo");
        person.setAge(30);
        person.speak();
    }
    
}

main方法细节:
a.每个类中都可以存在main方法，但是当执行的时候，会优先查看public 的class 中是否有main 方法.
b.如果没有public 的class, 那么会按照文件名优先查找类中的main方法
c.必须定义为public.
三. 优先原则:
优先原则: 对于一个类的成员方法来说，如果传递的形参的变量名称和类的成员变量名称相同，jvm在处理的时候优先当做方法的形参来处理.

四. this 关键字
1.含义:
代表了当前对象的引用.
可以理解为，当前谁来调用，那么方法中的this 就代表谁。

对于成员变量可以区分出来的场景，this 可加也可以不加，实际效果相同。
但是对于实现javaBean/POJO 来说，我们建议都加上在setXXX,getXXX方法中.

this:
可以加在成员变量的前面来指定对应的引用，也可以加在成员方法的前面。

课堂练习：

public class DemoClassTest{
    public static void main(String[] args){
        
        //第一种方式:
        //在构造方法执行前进行赋值，并且该类每个实现的对象，都会被初始化为该值.
        //意义: 当我们真的需要一个类的所有对象某些成员变量的值一致的时候。
        Person person = new Person();
        person.entity = "Japan";
        person.showEntity();
        
        //第二种方式
        //构造方法中直接进行赋值.
        //意义： 可以在创建对象的同时进行赋值，同时还可以动态的指定设定的值是什么
        Person person1 = new Person(40);
        person1.showEntity();
        
        //第三种方式
        //通过调用某个设置值的方法进行赋值,在对象创建完成之后
        //意义: 动态的修改成员变量的值.
        Person person2 = new Person();
        person2.showEntity();     
        //person.age = 12 //error
        /*
        person.setAge(12);
        person.eat();
        
        Person person1 = new Person();
        person1.setAge(15);
        person1.eat();
        */
               
    }
}

class Person{
        
        //改成员变量就不可被外部访问(外部: 类之外)
        int age=20;
        static String entity;
        
        //是给成员变量赋值
        
        //优先原则: 对于一个方法来说，如果传递的形参的变量名称和类的成员变量名称相同，jvm在处理的时候优先当做方法的形参来处理.
        
        Person(){
            
        }
        
        Person(int age){
            this.age = age;
        }
        
        void setAge(int age){
            this.age = age;
        }
        
        //拿到成员变量的值
        int getAge(){            
            return this.age;
        }
        
        void eat(){
            System.out.println("eat :"+this.age);
            speak();
        }
        
        void outputAge(){
                System.out.println(this.age);
        }
        
        void speak(){
            System.out.println("speak!");
        }
        
        void showEntity(){
            System.out.println("Entity:"+entity);
        }
        
}


五. 初始化类成员变量的方式
a.在定义成员变量的同时进行赋值.
b.提供外界可访问到的方法，在方法中进行赋值.
c.通过构造方法进行赋值.
六. static

a.随着类加载而加载
静态方法区中来保存静态成员变量

b.优先于对象创建
Person.className = "java";

c.被类的所有对象共享
静态的成员变量会保存在该class的静态方法区中，所以每个对象看到的都是同一份.

d.可以通过类名来访问也可以通过对象名来访问。
效果是一样的。

e.推荐通过类名来访问
f.静态的成员，一般称为类相关的成员。

f.static 修饰符既可以修饰成员变量，也可以修饰成员方法。 且修饰之后，就可以通过类名来直接访问到。

g.this变量在静态方法中不可以使用

h.静态方法中只能访问静态成员变量和静态方法。
  非静态方法既可以访问静态成员和方法也可以访问非静态成员和方法。
 
  非静态虽然可以访问静态的方法，但是不建议这样做。
课堂练习： 
public class DemoStatic{
    public static void main(String[] args){
        Person person = new Person();
    
        Person.action();
        //Person.speak();
        
        /*
        person.name="ryan";
        System.out.println(new Person().name);
        System.out.println(Person.name);
        */
        method();
    }
    
    static void method(){
        System.out.println("method");
    }
}

class Person{
    static String name = "diffo";
    static int age = 20;
    
    void speak(){
        System.out.println("speak:"+age);//静态方法无法访问非静态方法，运行结果如图所示错误。加上Static之后可正常运行，运行结果如图所示。

    } 
    static void action(){
        speak();
    }

}

七. main方法.

修饰符 返回类型  方法名 (参数列表){
}
public static void main(String[] args){
}
public: 最大的一个访问权限，使得jvm能够成功调用
static: 类相关的，与对象无关. A.main([]);
public class A{
   main(){
    System.("");
   }
}
void: 不需要返回值.
方法名: main
参数列表: 执行的时候，可以传递参数.
八. 工具类.

全部都是静态的方法。所以可以通过 类名.functionName() 方式来访问。

一般的话，都会对默认构造方法进行私有化处理，来防止别人使用时习惯性的创建对象来调用方

课堂练习：

public class ClassTestFinal{
    
    public static void main(String[] args){
        Square square = new Square();
        square.setLength(2);
        
        System.out.println(SquareUtil.getCircumLength(square));
        System.out.println(SquareUtil.getArea(square));
    }
    
}

//pojo类
class Square{
    private int length;
    
    void setLength(int length){
        this.length = length;
    }
    
    int getLength(){
        return this.length;
    }
}

//正方形工具类
class SquareUtil{
    
    private SquareUtil(){
        
    }
    
    static  int getCircumLength(Square square){
        return 4*square.getLength();
    }
    
    static   int getArea(Square square){
        return square.getLength()*square.getLength();
    }
}