5.面向对象（一）

一、面向对象和面向过程的区别

二、类和对象
对象：具体的事物，具体的实体，模板下的产品
类：对对象向上抽取出像、公共的部分，形成类，类是抽象的是一个模板
三、面向对象的三个阶段
1.面向对象分析（OOA）
对象抽取一个类
类中含有：
动词---->动态特性—>方法
名词---->静态属性—>属性
2.面向对象设计(OOD)
创建类：
创建对象：为所创建的对象开辟空间，并且初始化赋值属性
3.面向对象编程(OOP)
四、局部变量与成员变量
1.位置：
局部变量：方法中定义的变量（必须进行初始化）
成员变量：类中方法外定义的变量（栈中）
2、作用范围
局部变量：只在当前方法中只用
成员变量：当前类的所有方法中
3.是否有默认值
局部变量：无
成员变量：有

基本类型	默认值
boolean	False
char	‘\u0000’
byte	(byte)0
short	(short)0
int	0
long	0L
float	0.0f
double	0.0d

五、构造器
1、构造方法的调用
new 关键字就是在进行构造方法的调用，没有构造器时系统将会自动默认分配构造器，但当自定义构造器之后，系统将不会再分配构造器
2、构造器的作用
为对象的属性赋值，但不能在构造器中赋值，赋值后所有属性值都会一样，只要保证空构造器的存在即可
3、构造器与方法的区别
（1）构造器的结构
（修饰符） 构造器的名字（）{

}
（2）区别
a.没有return值
b.没有返回值类型
c.构造器的名字必须和类名相同
4.构造器的重载
（1）一般保证构造器的存在，空构造器中一般不会进行属性的赋值操作
（2） 一般我们会重载构造器，在重载的构造器中进行属性的赋值
（3）在重载构造器以后，空构造器没有写，系统不会再进行默认分配构造器了，需要加入空构造器
（4）属性名和形参名重名是会出现就近原则解决办法
（5）再要表示对象的属性前加上this. this. 代表你创建的那个对象

public class Person {
    //属性
    String name;
    int age;
    int weight;
    //构造器：没有任何参数的构造器造作空参构造器
    public Person(){

    }
    public  Person(String name,int age,double weight){
        this.name=name ;
        this age=age;
        this weight=weight;
    }

六、内存分析
1.

public class Person{ 
//成员变量
	int ad;
	int age;
	public static void main(String args[])
		Person p1=new Person();
		System.out.println(p1.age);
}

内存分析图

2.

public class Person1 {
    int id;
    int age;
    String school;
    public Person1(int a,int b,String c){
        id=a;
        age=b;
        school=c;
    }

    public static void main(String[] args) {
        Person1 p=new Person1(1,20,"china");
    }
}

七、this关键字的使用
1.修饰属性
当属性名和形参名发生重名时或者属性和局部变量发生重名时，会发生就近原则，直接使用变量名字指的是形参或者局部变量，要表示属性是需用this修饰，不发生重名问题实际上访问属性也有this只是省略了。
（this指代当前使用和构造的对象）

public class Person {
    //成员变量
    int age;
    String name;
    double weight;
    //空构造器
    public Person(){
    }
    //有参构造器
    public  Person(int age,String name,double weight){
        this.age=age;
        this.name=name;
        this.weight=weight;
    }
    public void eat(){
        int age=10;
        System.out.println(age);//就近原则  out:10;
        System.out.println(this.age);//out:19;指代的是属性的age
        System.out.println("I like eat");
    }
}

2.this修饰方法
在同一个类中，方法可以互相调用，this.可以省略

public void play(){
        this.eat();//this.可以省略;
        System.out.println("踢足球");
        System.out.println("跑步");
    }
    private void eat(){
        System.out.println("吃饭");
    }
}

3.this可以修饰构造器
同一类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行

public  Person(int age,String name,double weight){
        this(age,name);//this修饰构造器
        this.weight=weight;
    }
    public  Person(int age,String name){
        this(age);//this修饰构造器
        this.name=name;
    }
    public  Person(int age){
        this.age=age;
    }

八、static关键字
static可以修饰：属性，方法，内部类，代码块
1.static修饰属性

public class static {
    //成员变量
    int id;
    static int sid;

    public static void main(String[] args) {
        stati t1=new stati();
        t1.id=10;
        t1.sid=10;
        stati t2=new stati();
        t2.id=20;
        t2.sid=20;
        stati t3=new stati();
        t3.id=30;
        t3.sid=30;
        System.out.println("t1.id\tt2.id\tt3.id");
        System.out.println("t1.sid\tt2.sid\tt3.sid");

官方的推荐的访问模式：可以通过类名.属性名的方式去访问

stati.sid=100;
System.out.println(sid);

static修饰属性总结
（1）在类的加载的时候一起加载入方法区中的静态域中
（2）先于对象存在
（3）访问方式 对象名.属性名或者类名.属性名
static使用情景
当前的方法多次调用这个变量，且改变量不改变

public class XuptSchool {
    String name;
    int age;
    static String school;
    public static void main(String[] args) {
        XuptSchool.school="xupt";
       XuptSchool s1=new XuptSchool();
       s1.name="lili";
       s1.age=19;
       XuptSchool s2=new XuptSchool();
       s2.name="sara";
       s2.age=20;
        System.out.println(s1.school);
        System.out.println(s2.school);
        System.out.println(s1.age);
        System.out.println(s1.name);
    }
}

2.static修饰方法
（1）普通方法
既可以访问静态属性也可以访问非静态属性
（2）静态方法
public和static都为修饰符没有先后顺序的关系
被static修饰的方法在加载类的时候会首先加载这个方法，先于对象加载，被所有对象共享

static public void(){
}

静态方法不能访问非静态方法
静态方法只能访问静态属性
静态方法中不能使用this关键字（先于对象的存在）
（3）调用
a.非静态方法
对象名.方法名
b.静态方法
类名.方法名
对象名.方法名

public class Demo {
    int id;
    static int sid;
    public void a(){
        //在普通的方法中既可以访问静态属性也可以访问非静态属性
        System.out.println(id);
        System.out.println(sid);
    }

    //1.static和public都为修饰符，没有先后顺序关系
    //2.被static修饰的方法在加载类的时候会优先被加载，先于对象加载，被所有该类的对象共享
    static public void b(){
        //1.a();在静态方法中不能访问非静态的方法
        //2.System.out.println(id);在静态方法中不能访问非静态的属性,先于对象存在
        //3，this.id在静态方法中不能使用this关键字
        System.out.println(sid);

    }

    public static void main(String[] args) {
        //非静态方法可以用对象名.方法名调用；
        Demo d=new Demo();
        d.a();
        //静态方法可以用对象名.方法或者类名.方法调用
        Demo.b();
        d.b();

    }
}

3.static修饰代码块
类的组成：
属性、方法、构造器、代码块、内部类
代码块的分类：普通块，静态块、构造块、同步块
（1）普通块
定义在方法中。其中变量右局限性，只能在代码块中使用

 public void a(){
        //普通代码块（方法中）
        System.out.println(a);
        System.out.println(sa);
        {
            int num=1;
            System.out.println(num);
            System.out.println("这是一个普通块");
        }
        //if(num){范围在括号当中

        }

（2）静态块
定义在方法外，用static修饰，只能访问静态属性和静态方法

static{//静态块
            System.out.println("这是一个静态块");
            //只能访问静态属性和方法
            System.out.println(sa);
            b();

        }

（3）构造块
定义在方法外的代码块

 {//代码构造块(方法外)
            System.out.println("这是构造块");
        }

4.执行的顺序
a.先执行静态块，只在类加载是执行一次，一般用于工厂，数据库的初始化信息放入静态块，一般用于执行一些全局性的初始化操作
b.在执行构造块
c.执行构造器
d.执行方法中的普通块

public class Test {
    //属性
    int a;
    static int sa;
    //方法
    public void a(){
        //普通代码块（方法中）
        System.out.println(a);
        System.out.println(sa);
        {
            int num=1;
            System.out.println(num);
            System.out.println("这是一个普通块");
        }
        //if(num){范围在括号当中

        }

    public static void b(){

    }
        {//代码构造块(方法外)
            System.out.println("这是构造块");
        }
        static{//静态块
            System.out.println("这是一个静态块");
            //只能访问静态属性和方法
            System.out.println(sa);
            b();

        }
    //有参构造器
    public Test(int a){
        this.a=a;//构造器为成员变量赋值
    }
    //空构造器
    public Test(){
        System.out.println("这是一个空构造器");
    }

    public static void main(String[] args) {
        Test s=new Test();
        s.a();
        Test t=new Test();
        t.a();
    }
}

九、包
1.包的作用
为了解决重名问题（实际上对应着盘符上的目录）
解决权限问题
2.包名定义
(1)全部为小写
(2)中间用.隔开
(3)一般为公司域名倒着写。例：com.jd com.albb
(4)加上模块的名字
com.jd.login com.jd.register
(5)不能使用系统的关键字。nul,con,com1,com9;
(6)包声明的位置一般都在非注释性代码的第一行
3.导包问题
（1）使用不同包下的类需要导包：import java.util.Date
（2）在导包后想用其他的包下同名的包，需自己手动写所在的包
（3）同一个包下的类想使用不需要导包，可以直接使用
（4）在java.lang包下的类直接使用无需导包
（5）导包快捷键：alt+enter
（6）java.util意为将util下所有类都都直接导入
5.在java中导包没有包含与被包含的关系
import static java.lang.Math.;
导入Java.lang下的Math类中的所有静态的内容

package com.twx;
//非静态导入
import static java.lang.Math.*;
//导入java.lang下的Math类中所有的静态类容
import java.util.Random;
public class Person {
    public static void main(String[] args) {
        System.out.println(new Random());
        System.out.println(PI);
        System.out.println(round(3.2));
    }
    //在静态导入后同一个方法中右相同的类的时候，优先走自己定义的方法
    public static int round(double a){
        return 1000;
    }
}