Java面向对象3

内容都是根据B站宋红康老师的视频课做的总结用于复习.....

再提一下方法形参的传递机制:值传递. 当我们调用方法的使用,实参赋值给形参的是1.数据值(基本数据类型) 2.地址值(包括数据类型).记住的是这个,并且它适用于其他赋值,

a =b;
a和b都是基本数据类型

d = c;
//d和c都是引用数据类型

有个问题,有两个类, Person 和 User

Person p1 =new Person();
User u1 = p1;
这样编译不通过.既然引用数据类型的变量值都是地址值,
那为什么还会不通过呢?

p1实际上还包括了数据类型,不仅仅是地址值.

还有一个问题,涉及到方法传参和String类型.

String name ="hello";

首先,String类型是一个特殊的引用数据类型,它没有new,事实上它也可以通过new来初始化.
其次,new出来的结构保存在方法区的字符串常量池内.并且它的底层实际上是一个char[],char
型数组,数组是不可变的,所以不可以在原位置上修改

public void change(String s){
    s ="hi~~~";
}

t1.change(name);
打印出来name的值没有变.

方法形参获取的仍然是地址值,但是,原地址值上面不可以修改,所以在字符串常量池内新开辟了一个内存空间保存"hi~~",s指向这个内存空间,方法调用结束.name原地址值上的字符串没有被改变.

这部分谈构造器,this关键字和package以及import关键字..

构造器给我的感觉像是Pyhon里面的 __init__,构造器=constructor = 构造方法,事实上,任意一个类里面都有构造器.我们之前定义的类没有显式声明构造器,系统(老师用的这个词,我也不知道说的是什么系统)会自动提供一个空构造器.

public Studen(){}//什么都没写

构造器的作用:
1.创建对象
class Person{
    String name;
    int age;
    public Person(){}
}
2.初始化对象的属性
    class Person{
    String name;
    int age;
    public Person( String n, int i){
    name = n;
    age =i;
    }
}
Person p1= new Person("zhang san",22);
//这样实现了属性的初始化,不同于上面的默认初始化.

定义构造器的格式

权限修饰符 类名(参数列表){
      
}
构造器的主要目的是初始化对象,但它和普通的方法其实没有太大的区别

public Person(){
    System.out.println("hello world");//初始化对象,这句也是会执行并且打印出来的...
}


构造器和方法的区别
方法是用来实现某些功能的,通过"对象.方法"的方式调用
而构造器是用来创建对象的...就目前我看到的例子而言,功能上来说就是
怎么初始化属性.




构造器的特征:
1.与类同名
2.不声明返回值类型(与声明为void不同)
3.不能被static、final、synchronized、abstract、native修饰，不能有
return语句返回值

构造器的细节说明...

1.一个类可以定义多个构造器,彼此之间形成构造器的重载
public class Person{
    String name;
    int age;
    public Person(){}
    public Person(int age){
        this.age =age;
    }
    
    public Person(String name){
        this.name =name;
    }
    public Person(String name,int age){
        this.name =name;
        this.age =age;
    }
}
以上都构成了构造器的重载...

2.一旦我们显式地提供了构造器之后,系统就不会提供默认的构造器.
默认的空参构造器和类的权限相同,即具有相同的权限修饰符...public的类,系统默认提供的构造器就是publi的,缺省的类,默认构造器就是缺省的!

    所以如果我们定义了其它构造器,一般要补上默认的空构造器.
    


3.一个类中至少有一个构造器..

public Person(){
    age =18;
}
public Person( String name,int age){
    this.age = age;
    this.name =name;
}
//如果我们使用上面的构造器

Person p1 = new Person();age的默认值为18,而非int型的0

//下面的构造器
Person p2 =new Person("Jerry",23);可以得到创建对象的时候就给
属性赋值...
并且我们也可以在里面加上比如if条件判断去给属性赋值增加条件!

public class Car {
	
	//讲了封装性,对象的属性一般会用private权限修饰..
	private String type;
	private double speed;
	private Teacher teacher;

	public Car() {//实际开发中,一般会给到一个空参构造器...
		
		
	}

	public Car(String type, Teacher teacher, double speed) {
		this.teacher = teacher;
		this.speed = speed;
		this.type = type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public String getType() {
		return type;
	}

	public void setSpeed(double speed) {
		this.speed = speed;
	}

	public double getSpeed() {
		return speed;
	}

	public void setTeacher(Teacher t) {
		this.teacher = t;
	}

	public Teacher getTeacher() {
		return teacher;
	}

	//提供了两个方式来给属性赋值,new的时候根据构造器重载选择相应的方法.还有就是根据set方法传参进去
	//只提供了一个方法来查看属性的值.get方法.
	//一定要写熟练get和set方法.我感觉我写的已经很快了,打字速度跟不上.....
	
}

上面的定义类的时候我故意加了一个Teacher属性..

这个属性是个对象,因为之前接触的较少,这里写一下这个属性的赋值.

1.
Teacher t1 = new Teacher();
Car c1 = new Car("五菱",t1,100);

当然也可以使用匿名对象给对象赋值.
c1= new Car("五菱",new Teacher(),120);

2.
c1.setTeacher(new Teacher());

总结对象中属性赋值的过程,按照赋值的先后顺序

1.默认初始化值
int age;

2.显式初始化值
int age=18;

3.构造器中赋值
public Person(int a){
age =a;
}

4.通过"对象.属性"或者"对象.方法"的方式来实现赋值.当然.属性的权限修饰要不是私有的才能通过对象.属性赋值

关于2和3,如果在属性声明的时候显式初始化,但是用又用了构造器,结果是构造器的那个赋值.

Java bean的使用.

Java bean 是一种Java语言写成的可重用组件.
在Java web中会学到具体的使用

之前也看到过bean这个词,好像外国人还挺喜欢来拿这个词打比方的.

Java bean的定义.
Java bean是指符合如下如下标准的类,1.类是公共的 2.有一个无餐的构造器 3.有属性,并且有相应的get和set方法.满足这样标准的类就可以成为Java bean. 


为什么要一个空参构造器,为了方便造对象,开发中,除了new出对象,还可以通过反射的方式造出对象,而反射用的就是空参构造器.造完对象之后,属性是默认的,通过get和set方法把数据库中的值装入对象之中.


用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

this调用属性和方法.现在讲this关键字.

this是什么?this是指当前对象.

在方法内部使用,即这个方法的所属对象的引用
在构造器内部使用,即表示该构造器当前正在创建的对象.


使用this来区分属性和局部变量
public void setName(String name){
    this.name =name;
}
this.name就是指的当前对象的name属性!

class Book{
    String name;
    String author;
    public void setAuthor(String author){
        //author = author;
        //这样会报错,编译器不能区分哪个是局部变量,哪个是属性
        
        //创建对象,调用方法,创建author局部变量,参数 ,author获取数据值
        //然后进入方法体再一次赋值...

        //所以要引入this来表示当前变量,排除这种混乱.
        this.author = author;
        //this只来表示当前变量,如果形参名不和属性名冲突,可以不适用this
           
}

对于this的理解,我认为我们定义类的目的就是创建对象,实例化对象

创建了一个个对象a1,a2,a3...an

但是很多时候我们需要在类里面引用当前的对象,而不是引用其他对象.
从顺序上来看,当前阶段还在创建对象,还没有实例化,所以我们也不知道当前对象是哪个.a1,a2,a3...?
所以引入了this可以抽象的指代当前对象,里面只要有this去修饰,this的意义就是指代当前对象.


p1.setAge(10);//方法体内的this就是p1对象

1.this可以用来修饰属性,方法和构造器.


2.this修饰属性和方法.
2.1在类的方法中,我们可以使用"this.属性"或者"this.方法"来调用当前对象的属性和方法.但是,我们通常情况下选择了省略"this.".特殊情况下,属性和形参名相同的时候使用"this.属性",表示这是当前对象的属性而非形参.

2.2在类的构造器当中,我们可以使用"this.属性"或者"this.方法"的方式来调用当前正在创建的对象的属性或者方法.但是我们通常情况下选择省略掉"this.", 特殊情况下,构造器形参和属性同名的时候,需要用到"this.属性"的方式表示当前对象的属性...

 this调用构造器.

目前我们定义的类需要初始化的东西很少
name,age,color等少数属性需要赋值,

如果我们有40个属性,我们赋值或者处理的的东西就有一大堆
class Person{
    private int age;
    private String name;
    public  Person(){
    //这是一个空参构造器
    String info = "这是40行可执行代码需要处理";
    System.out.println(info);
    
    //我们使用了一个字符串代表了大量代码
    //创建对象的使用,如果使用的空参构造器,上面的代码会执行并且会打印出来
    //但是,如果这里面的代码有一部分是公共的,是下面构造器也需要考虑的..
    //如果,我们频繁的在下面的构造器里面复制粘贴这些公共的代码,会造成冗余

    //因而...用this(参数列表)解决
    //调用这个this(参数列表结构,会调用相应的构造器.)
    }
    public Person(String name){
       this();//无参数,会执行上面的空参列表,现在假设那40行代码就是公共的.
       this.name =name;   
    
    }
    public Person(int age){
        this();
        this.age =age;

    }
    public Person(String name,int age){
        this(age);有参数,并且参数是int型的,会匹配到上面的构造器,并且执行那个构造器.
        //形参age 会传入this() 执行Person(int age)里面的相应代码
        //并且age是形参. 上面的执行,this.age=age会完成赋值,也就是实现了我们的需求
        
        this.name =name;
        //不仅如此,后面的代码也会执行
        //这样就减少了大量的代码冗余
        //


    }
    

}


也可以把这些代码封装进方法里面,然后再在构造器里面调用方法.




3.1关于列在类中的构造器,我们可以显式的使用this(形参列表)来调用类中指定的相应的构造器.

3.2 构造器中不能通过this()调用自身,这样就形成了递归调用导致栈溢出.
上面的Person类中用了各种各样的this(),但最终只会有一个构造器会执行

3.3如果一个类中有n个构造器,最多可以使用n-1个this(形参列表)

3.4 this(形参列表);这种调用只能放在每个构造器的行首并且一个构造器内部只能有1个这样的调用.这样也区别了方法,方法在构造器中任何位置.

package关键字的使用.

package(包)


我们创建java程序的步骤是:
1.创建java工程.
2.在工程下面创建包
3.在包里面创建类.

我们写Java,大一点的项目可能就需要几十上百个类,因而需要包的概念,来管理各个类,目的的是做出区分

使用package声明类所属的包,
其实我使用eclipse创建类的时候它已经packag自动声明了.
比如我在com.atguigu.review1包下面写各个类,每个类都会自动的声明自己所属的包,如下:
package com.atguigu.review1;


关于包名
我们一般拿公司的网站写在前面,并且是倒着写
比如:com.4399.java 包名的规范是全小写,后面的.代表着一层文件目录
在这个包下面写的java源程序是在com文件夹下的4399文件夹下的java文件夹下,事实上,我们创建包是在src文件夹下...
在java中不同的包可以有同名的接口和类,而在同一个包下则不能定义同名的类和接口..

Java主要的包
java.lang包,language的缩写,包含Java的核心类,包含String,Math,Interger,System等

java.util包 
java.net
java.io
java.text
java.sql

import关键字的使用.在源文件中显示的使用,用于导入指定包下的类和接口,声明位置在类声明和包package声明之间.导入多个包,并列导入即可.快捷键是Ctrl+shift+o
如果需要导入同一个包下的多个类,比如java.util包下的Arrays,ArraysList,Hashmap等类,只需要显示的导入import java.util.* 
String类,System类没有导包,这是因为在java.lang下的类和接口无需导包,
在`com.4399.exer1 和com.4399.exer2包下都有Game类,并且我们两个都需要导入,首先导入一个import,剩下的那个就要写全类名才能使用 com.4399.exer.Game game = new com.4399.exer.Game();  全类名在开发中是有实际诉求的,比如Date类就要用到全类名导入.
import xxx导入的是xxx包下的类和接口,但是不包含xxx包下的子包.比如lang包不需要导入,但是import java.lang.reflect.Filed   Filed类则需要导入,因为它是子类里面的.