java面向对象-类和对象

Java面向对象笔记

java面向对象

类和对象

什么是类

类：类是一个模板，他描述一类对象的行为和属性。
对象:对象是类的一个实列，有属性和行为。

定义

实用class，声明类的名字
列：

calss Stuaent{
//声明这个是一个学生类，其中有年龄，姓名，性别属性.
//方法为吃饭，睡觉和学习。
	int age;
    String name;
    Steing sex;
    void eat(){
       System.out.println(name+"正在吃饭");
    }
    void sleep(){
        System.out.println("睡觉"):
    }
    void study(){
        System.out.println("学习");
    }
}

创建和使用

public class Test{
	public static viod main(String{}args){
        Student stu=new Student();//设置对象的属性
        stu.age=12;
        stu.name="小明";//33.34.35为设置对象的属性
        stu.sex="男";
        System.out.println("我叫"+stu.name+"今年"+stu.age);
        stu.eat();
        stu.sleep();//37.38.39为调用对象的方法
        stu.study();
	}
}
class studnet{
	int age;
	String name;
	String sex;
	void eat(){
		System.out.println(name+"正在睡觉");
	}
	viod sleep(){
		System.out.println("睡觉");
	}
	viod study(){
		System.out.println("学习");
	}
}

公式

类名 对象名 = new 类名();

给对象的属性赋值：

对象名.属性名 = 值;

使用对象的属性：

对象名.属性名

调用对象的方法：

对象名.方法名();

帮助资料

构造方法

什么是构造方

对象被创建的时候会调用的方法，对象在被创建的时候，也就是被new的时候，会自动调用构造方法

怎么定义和使用构造方法

总结
1.构造方法可以有参数，也可以无参数；
2.构造方法无返回值，也不需要声明viod关键字；
3.构造方法名必须和类名相同。

实列

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JoEt832w-1618734509458)(D:\学习资料\图片\QQ图片20210201222309.png)]
文献

This关键字

什么是成员变量

this关键字

this即代表自己，this.属性访问的是自己的属性，this（）访问的就是自己的无参构造方法。
例一：this.属性

例二：this.属性，this（）

输出：
I am
张三
如把this.name=name改成name=name==，
那么结果为：
I am
null

/、备注：this()调用的是自己的无参构造方法

this.属性访问的是对象自身的属性，而方法参数中的name表示方法传入得值。

包的概念

在之前我们定义类和定义方法都是在一个文件中编写的，但是在实际开发过程中我们肯定不能使用一个文件去编写所有的代码。
怎么解决这个问题呢？
Duang，包，登场了，包就像我们windows系统中的文件夹一样，只不过包是专门存放代码文件的。
包的主要作用就是给代码文件分类。

如果一个类被定义在某一个包先那么在定义类的时候需要声明包名，否则程序会报错。
如：

实列：
实战教程

static关键字

什么是static关键字

static是静态的意思，是一个修饰符，就像是一个形容词，是用来形容类，变量，方法的。
static修饰变量，这个变量就变成了静态变量，修饰方法这个方法就成了静态方法，
static关键字方便在没有创建对象的情况下来进行调用（方法/变量）。

static关键字的作用

1.修饰变量

不实用static关键字访问对象的属性：

使用static关键字访问对象的属性：

**注意：**如果一个类的成员变量被static修饰了，那么所有该类的对象都共享这个变量。无论这个类实例化多少对象，他的静态变量只有一份拷贝。
如：

public class Test{
	public static void main(String[]args){
		Person p1=new Person();
		p1.name="张三"
		Person.name="李四"
		Person p2=new Person();
		Person p3=new Person();
		System.out.pritnln(p1.name);
		System.out.pritnln(p2.name);
		System.out.pritnln(p3.name);
	}
}
class Person{
	static String name="张三丰"；
	int age;
}
//输出的结果为：
//李四
//李四
//李四

2.修饰方法

用static关键字修饰的方法叫做静态方法。静态方法我们已经用过，他有一个特点相信你已经很熟悉，那就是不需要创建对象就可以直接使用
如：

public class Test{
	public static void main(String[]args){
		Person.hello();//调用静态方法只需要类名、方法名即可
		Person p=new Person();
		p.hi();
	}
}
class Person{
	public static void hello(){    		//静态方法
		System.out.println("hello");
	}
	public void hi(){					//普通方法
		System.out.println("hi");
	}
}

注意：

1.静态方法不能使用类的非静态变量；

2.静态方法可以直接调用静态方法，但是调用普通方法只能通过对象的实例才能调用。
3.

3.静态代码块

我们先来看一段静态代码块的运行效果：

public class Test{
	static{
	//静态代码块
	System.out.println("我被调用了");
	}
	public class static void main(String[]args){
	}
}

输出结果：
我被调用了
上中static{}就是一个静态代码块。
我们在main方法中没有编写任何代码，可是运行的时候，程序还是会输出我被调用了，由此我们可以发现静态代码块是不需要依赖main方法就可以独立运行的。
关于静态代码块你只需要记住一句话：在被加载的时候运行且只运行一次。
静态代码块中变量和方法的调用也遵守我们之前所说的规则，即只能直接调用静态的属性和方法。
**注意：在Java中是不能用static关键字修饰局部变量的，

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-toWkf7xP-1618734509467)(D:\学习资料\图片\屏幕截图 2021-03-08 150349.png)]

封装，继承和多态

什么是封装

封装：就是隐藏对象的属性和实现细节，
仅对外提供公共访问。封装是权限控制符区别如下：

封装的意义

对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。使用封装有四大好处：
1.良好的封装能够减少耦合。
2.类内部的结构可以自由修改。
3.可以对成员进行更精确的控制。
4.隐藏信息，实现细节。v

封装把一一个对象的属性私有化，同时提供一些可以被外界访问的属性，如果不想被外界访问 ，我们大可不比提供方法给外界访问。但是如果一个类没有提供个外界访问的方法，那么这个类也没有什么意义，

实现封装的步骤

1.修改属性的可见性来限制对属性的访问（一般限制为Private，）例如：

public class Person{
	private String name;
	private int arg;
}

这段代码中，将name和arg属性设置为私有的，只有本类擦能采访，其他类都访问不了，如此就对信息进行了隐藏。
2.对每个属性提供对外的公开方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

/*
*封装演示
*/
public class Person{
	/*
	*封装性的封装 一个人的姓名、性别和年龄都是这个人的私有属性
	*/
	private String name ;
	private String sex ;
	private int arg ;
	
	/*
	*setter(),getter()是对象对外开放的接口
	*/
	public String getName(){
		return name;
	}
	
	public void setName(String name){
		this.name=name;
	}
	
	public String getSex(){
		return sex;
	}
	
	public void sexSex(String sex){
		this.sex=sex;
	}
	
	 public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
}

采用this关键字是为了解决实例变量（private String naem）和局部变量(setName(String name)中的name变量)之间发生的同名的冲突。

封装可以使我们容易修改类的内部实现，而无需修改使用了该类的客户代码，就可以队成员变量进行更精确的控制。

public void setAge(int age) {
    if (age > 120) {
        System.out.println("ERROR：error age input...."); // 提示错误信息
    } else {
        this.age = age;
    }
}

public String getSexName() {
    if ("0".equals(sex)) {
        sexName = "女";
    } else if ("1".equals(sex)) {
        sexName = "男";
    } else {
        sexName = "人妖";
    }
    return sexName;
}

资料帮助

继承的基本概念

所谓继承：是指可以让某给类型的对象获得另一个类型的对象的属性的方法。
java类的继承，可用下面的语法来表示：

class//定义父类
{
...
}
class 子类 extends 父类//用extends关键字实行类的继承
{
...
}

范例：

public class TestPersonStudentDemo{
	public static void main (String[]args){
	Student s=new Studnet();
		//访问Person类中的name属性
		s.name="张三"；
		//访问Person类中的age属性
		s.age=18;
		//访问Student类中的School属性、
		s.school="哈弗大学"；
		System.out.print("姓名"+s.name+",年龄："+s.age+",学校："+s.school)
	}
}
class Person{
	String name;
	int age;
}
class Student extends Person{
	String School;
}

继承的特性

1.子类拥有父类非private的属性和方法；
2.子类可以拥有自己的属性和方法、
3.子类可以用自己的方式实现父类的方法；
4.在java中只允许单继承，而不允许多重继承，也就是说一个子类只能有一个父类，但是java中却允许许多继承，多层继承就是，例如类从c继承类b，类b继承类a，所以按照i关系就是类a是类a的父类，类b是类c的父类，就是java继承区别与c++继承的一个特性;
5.提高了类之间的耦合性（继承的缺点，耦合度提高就会造成代码之间的联系）。
多重继承：

class A{
...
}
class B{
...
}
class C extends A,B{
...
}

由上可知c类同时继承了类A和类B，也就是说类C同时继承了两个父类，这在Java中是***不允许的***。
多层继承:

super关键字

用法：

1.super可以用来引用直接父类的实例变量。
2.super可以用来调用直接父类的方法。
3.super可以用来调用直接父类构造函数。

1.用于直接父类实例变量

public class TestSuper1{
	public static void main(String[]args){
		Dog s = new Dog();
		s.printcolor();
	}
}
class Animal{
	String color= "White";
}
class DOg extends Animal{
	String color="black";
	void printcolor(){
	System.out.println(color);
	System.out.println(super.color);
	}
}

输出结果:
black
White
如上所示如打印color将默认打印当前类的颜色。要用父类属性则要使用super关键字指定。

2.通过super来调用父类方法。

public class TestSuper2{
	public static void main(String []args ){
	
	}
}
class Ainmal {
	void eat(){
		System.out.println("eatign···");
	}
}
class Dog extends Ainmal{
	void eat(){
		System.out.println("eating bread···");
	}
	void bark(){
	System.out.println("barking···");
	}
	void work(){
	super.eat();
	bark();
	}
}

输出结果：
eating···
barking···
在上面中在Ainmal和Dog中都有eat（）方法，如果需要调用Ainmal中的eat()方法则需要使用super关键字 ，因为当前类的优先级比父类优先级高，所以调用本类的方法时可直接调用，而调用父类时需要使用super.方法名()

3.使用super来调用父类构造函数

public class TestSuper3{
	public static void main(String args[]){
	
	}
}
class Ainmal {
	Ainmal(){
		System.out.println("animal  is created");
	}
}

class Dog extends Ainmal{
	Dog(){
	super();
	System.out.println("dog is created");
	}
}

输出结果：
animal is created
dog is created
注意：如果没有使用super()``thsi(),
则super()在每个类构造函数中由编译器默认自动添加。

super与thsi关键字的比较

super关键字:我们通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字:指向自己的引用。
范例：

public class TestAnimalDogDemo {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.eat();
        Dog d = new Dog();
        d.eatTest();
    }
}
class Animal {
    void eat() {
        System.out.println("animal : eat");
    }
}
class Dog extends Animal {
    void eat() {
        System.out.println("dog : eat");
    }
    void eatTest() {
        this.eat(); // this 调用自己的方法
        super.eat(); // super 调用父类方法
    }
}

输出结果：
animal:eat
dog:eat
animal:eat

上表对this与super的差别进行类比较，从上表中不难发现，用super或this调用构造方法时都需要放在行，所以super与this不能同时出现的。

方法的重写与重载

方法的重写（override）

1.方法的重写

子类从父类中继承方法，可则对父类中同名同参数的方法，进行覆盖操作

2.应用：重写以后当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是 子类重写父类的方法

3.重写的规定：

​ 方法的声明：权限修饰符 返回值类型 方法名(i形参列表){

​ }

​ 约定俗称：子类中的叫重写的方法，父类中的叫做被重写的方法

​ ①子类重写的方法的方法名和形参列表与父类被重写的方法名和形参列表相同

​ ②子类重写的方法的权限修饰符不小于父类被重写的方法权限修饰符

​ >特殊情况：子类不能重写父类中声明为private权限的方法

​ ③返回值类型：

​ >父类被重写的方法的返回值类型是void ，则子类重写的方法的返回值也只能是void

​ >父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类

​ >父类被重写的方法的返回值类型是基本数据类型(比如，double)，则子类重写的方法的返回值类型必须是相同的数据类型。

​ ④子类重写的方法抛出的异常类型不大与父类被重写的方法抛出的异常类型

Employee e2 =new Programer;

e2.employee();//动态绑定

---

子类和父类中同名同参数的方法要么都声名的static(不是重写)，要么都声名非static（考虑重写）的,

方法的重载（overload）

1方法的重载

首先方法的重载是指多个方法可以享用相同的名字,但是参数的数量或类型不能完全相同.。
调用方法时，编译器根据参数的个数和类型来决定当前所使用的方法。方法的重载微程序的编写带来方便，是opo多态性的具体表型。在java系统的类库中，对许多重要方法进行重载，为用户使用这些方法提供了方便。

2.重载的规则

• 被重载的方法必须改变参数列表（参数个数或类型不一样）
• 被重载的方法可以改变放回类型
• 别重载的方法可以改变访问修饰符
• 被重载的方法可以声明新的或更广的检察异常
• 方法能够早在同一个类中或正在一个子中被重载
• 无法以返回值类型作为重载函数的区分标准

重写与重载之间的区别

方法的重写和重载是java多态性的不同表现，=重写是父类与子类之间多态性的一种表现，重载可以理解为多态的具体表型形式。

• 方法地重载是一个类中定义了多个方法名相同而类型和次序不同，则称之为方法的重载
• 方法重写是在子类存在方法与父类的方法名字相同而且参数的个数与类型一样，返回值也一样的方法，就称之为放法的重写
• 方法的重载是一个类的多态性的表现，而方法重写是子类与父类的一种多态性表现
  
  

抽象类

抽象类的概念

抽象类的定义规则：

• 抽象类和抽象方法都必须用abstract关键字来修饰；
• 抽象类不能被实例化，也就是不能用new关键字去产生对象；
• 抽象方法只需声明，而不需实现；
• 含有抽象方法的类必须声明为抽象类，抽象类的子类必须复写所有的抽象方法后才能被实例化，否则这个子类还是个抽象。
  抽象类的定义格式：

abstract class 类名称// 定义抽象类
{   
	声明数据成员;
	
	访问权限 返回值的数据类型 方法名称(参数...)//定义一般方法
	{
		...
	}
	
	abstract 返回值的数据类型 方法名称(参数...);
	//定义抽象方法，在抽象方法里.没有定义方法体
}

注意：

• 在抽象类定义的语法中，方法的定义可以分为两种：一种是一般的方法

型一样，返回值也一样的方法，就称之为放法的重写

• 方法的重载是一个类的多态性的表现，而方法重写是子类与父类的一种多态性表现
  [外链图片转存中…(img-7dTcVULh-1618734509475)]
  [外链图片转存中…(img-yrmpmnhn-1618734509476)]

抽象类

抽象类的概念

抽象类的定义规则：

• 抽象类和抽象方法都必须用abstract关键字来修饰；
• 抽象类不能被实例化，也就是不能用new关键字去产生对象；
• 抽象方法只需声明，而不需实现；
• 含有抽象方法的类必须声明为抽象类，抽象类的子类必须复写所有的抽象方法后才能被实例化，否则这个子类还是个抽象。
  抽象类的定义格式：

abstract class 类名称// 定义抽象类
{   
	声明数据成员;
	
	访问权限 返回值的数据类型 方法名称(参数...)//定义一般方法
	{
		...
	}
	
	abstract 返回值的数据类型 方法名称(参数...);
	//定义抽象方法，在抽象方法里.没有定义方法体
}

注意：

• 在抽象类定义的语法中，方法的定义可以分为两种：一种是一般的方法