投稿
  1. 首页
  2. java

Java面向对象篇

code • 2022-4-28 • java • 阅读 54

Java面向对象篇,第1张

一、面向对象三大特征 ——封装 1.封装 1.1什么是封装？

封装是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。

1.2怎么隐藏对象的属性？

想要隐藏对象的属性，只需要在定义属性的前面加上一个关键字private即可实现隐藏。

1.3怎么提供公共的访问方式？

就是在类中写上几个setXXX()和getXXX()，主要为了统一管理。

2.private关键字 2.1什么是private关键字？

是一个修饰符，代表私有的意思，可以修饰成员变量和成员方法和构造方法。

2.2private关键字的特点？

被private修饰的成员变量和成员方法只能在本类中使用，不能在其他类中使用。

2.3标准代码写法？ 
class Person {
			private String name; //私有变量。
			
			//公共访问方式。
			public void setName(String n) {
				name = n;
			}
			
			public String getName() {
				return name;
			}
			
		}
3.this关键字 3.1什么是this关键字？

this代表对象的引用，哪个对象调用this所在的方法，this就代表哪个对象。

3.2this关键字有什么用？

1.它可以解决局部变量隐藏成员变量的问题。
2.可以调用本类中的成员变量和成员方法和构造方法。

3.3标准代码写法？ 
class Person {
			private String name;
			
			public void setName(String name) {
				this.name = name;
			}
			
			public String getName() {
				return this.name;
			}
			
		}
4.构造方法 4.1什么是构造方法？

方法名和类名相同，和普通方法的格式不一样的特殊的方法。

4.2构造方法的定义格式？ 
	//格式：
	修饰符 类名(形参,...)
 	{
	执行语句;
	}
	
	public Person() {
	
	}
4.3构造方法的作用？

1.用来创建对象。
2.用来对象的属性进行初始化。

4.4构造方法的特点？

1.构造方法没有返回值类型。
2.构造方法没有返回值（有renturn，一般不写）。
3.构造方法的名字一定要和类名相同。

4.5构造方法的注意事项？

1.如果我们没有手动写构造方法的话，系统会默认带一个无参构造。
2.如果我们手动写了构造方法的话，系统默认带的无参构造就消失了。
3.构造方法也是方法，既然是方法，就会满足方法的重载，也就说一个类中可以写多个构造方法。

实例

class Person {
				//没有手动写构造方法实例
				public Person() {  //无参构造
				
				 }
				//手动写了构造方法实例以及多个构造方法实例。
				public Person(String name) {  //有参构造
				
			 	}
				
				public Person(int age) {
				
				}
				
				public Person(String name,int age) {
				
			 	}
			}
4.6一个类中写多个构造方法有什么用呢？

1.可以根据不同的需求来调用不同的构造方法。

实例

class Demo {
	public static void main(String[] args) {
		//需求：孩子出生时候，没有姓名没有年龄
		Child c1 = new Child();
		System.out.println(c1.name + "..." + c1.age);//null...0
		
		//需求：孩子出生时候，有姓名，但是没年龄
		Child c2 = new Child("张三");
		System.out.println(c2.name + "..." + c2.age);//张三...0
		
		//需求：孩子出生时候，有姓名，有年龄
		Child c3 = new Child("李四", 18);
		System.out.println(c3.name + "..." + c3.age);//哪吒...18
	}
}
class Child {
	String name;
	int age;
	//构造一个空参方法。
	public Child() {}
	//三个不同的有参构造方法。
	public Child(String name) {
		this.name = name;
	}
	
	public Child(int age) {
		this.age = age;
	}
	
	public Child(String name, int age) {
		this.name = name;
		this.age = age;
	}
}

2.有参的构造方法可以给属性赋值。

实例

class Demo {
	public static void main(String[] args) {
		//第一种赋值方法
		Person p = new Person();
		p.setName("tom");
		p.setAge(18);
		
		//第二种赋值方法。
		Person p = new Person("tom", 18);
	}
}

class Person {
	private String name;
	private int age;
	
	//构造一个空参方法。
	public Person() {}
	//构造方法应用：
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	//普通方法应用：
	public void setName(String name) {
		this.name = name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
	public String getName() {
		return this.name;
	}
	public int getAge() {
		return this.age;
	}
}
4.7通过有参构造给属性赋值和通过setXXX给属性有什么区别呢？

1.setXXX方式赋值可以使用N多次、有参构造方式赋值只能使用一次。
2.有参构造方式是先天的、setXXX方式是后天的。

4.8加上构造方法之后的标准代码怎么写？ 
class Person {
	private String name;
	private int age;
	//必须构造一个无参方法。
	public Person() {}
	//构造一个有参方法。
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	//根据需求构造普通方法。
	public void setName(String name) {  //获取普通方法
		this.name = name;
	}
	public String getName() {          //还回值方法。
		return name;
	}
	
	
	public void setAge(int age) {
		this.age = age;
	}
	public int getAge() {
		return age;
	}
}
5.static关键字 5.1什么是static关键字？

是一个修饰符，代表静态的意思，它可以修饰成员变量和成员方法，不能修饰构造方法。

5.2static关键字有什么特点？

1.被static所修饰的成员是随着字节码文件对象的加载而加载，所以是优先于对象存在于内存中。
2.被static所修饰的成员被该类下所有的对象所共享。
3.被static所修饰的成员可以通过类名.直接调用。

类名.属性名;
类名.方法名();

5.3static关键字的注意事项？

1.静态方法中不能有this关键字。
2.静态方法中可以调用静态成员变量和静态成员方法，但是不可以调用非静态的成员变量和调用方法。
3. 非静态方法中可以调用静态的成员变量和成员方法，也可以调用非静态的成员变量和成员方法。

实例

package com_1;

public class Demo01 {
	public static void main(String[] args) {
	
		System.out.println(Person.country);  //直接调用静态成员变量
		Person.eat(); //调用静态成员方法。
	}
}

class Person {
	String name;
	int age;
	//修饰静态成员变量country。
	static String country;
	
	//修饰静态成员方法eat().
	public static void eat() {
		//System.out.println(this);   如果添加这一句就会报错。
		System.out.println("吃");
	}
}
二、面向对象三大特征 ——继承 1. 什么是继承？

一个类的对象可以使用另一个类的对象中的成员，这种关系就称为继承。

2. 继承的格式？ 
class A {
		
		}
		
class B extends A {

}

//类B 继承 类A
//类A：父类，超类，基类
//类B：子类，派生类
3. 继承的好处是什么？

1.提高了代码的复用性。
2.让类与类之间产生了继承关系，这是构成多态的前提条件。

4. 继承的弊端是什么？

提高了代码的耦合性。
开发原则：高内聚，低耦合。
高内聚：是指这个类的能力越强越好。
低耦合：是指这个类的关系越少越好。

5. 继承的特点？

特点： 在Java中，类只支持单继承，不可以多继承，可以多层继承，不可以循环继承。
实例：

//单继承：
class Fu {}
class Zi extends Fu {}  //Zi继承Fu。

//多层继承：
class Ye {}
class Fu extends Ye {} //Fu继承Ye。
class Zi extends Fu {} //Zi继承Fu。

//循环继承：被禁止用，会陷入死循环。
class Fu extends Zi {}
class Zi extends Fu {}
6. 继承的注意事项？

1.子类不能继承父类中被private关键字所修饰的成员变量和成员方法。
2.子类不能继承父类中的构造方法。

实例：

class Fu {
	private String name; //私有的成员变量。
	int age;
	
	public void eat() {}
	private void drink() {} //私有的成员方法。
}

class Zi extends Fu {
	public void print() {
		System.out.println(name);//编译报错，因为父类的name被私有了
		System.out.println(age);
		eat();
		drink();//编译报错，因为父了drink()被私有了
	}
}
7. 我们在什么时候可以使用继承呢？

当两个类之间存在"is a"的关系的时候，我们就可以使用继承。
实例：

人类 is a 学生类 X  所以人类不能继承学生类
人类 is a 老师类 X  所以人类不能继承老师类

学生类 is a 人类  所以学生类可以继承人类
学生类 is a 老师类 X 所以学生类不能继承老师类

老师类 is a 人类  所以老师类可以继承人类
老师类 is a 学生类 X 所以老师类不能继承学生类


class Person {}
class Student extends Person {}
class Teacher extends Person {}
8. 在子父类继承中成员变量的关系？

在父类中有一个成员变量，在子类中有一个成员变量，在子类的成员方法中有一个局部变量。

  1. 三个变量的名字都不同的实例：
class Demo {
	public static void main(String[] args) {
		Zi zi = new Zi();
		zi.print(); //输出结果3、2、1。
	}
}

class Fu {
int i = 1;
}

class Zi extends Fu {
	int j = 2;
	
	public void print() {
		int a = 3;
		
		System.out.println(a);
		System.out.println(j);
		System.out.println(i);
	}
}
  1. 三个变量的名字都相同实例：
class Demo {
	public static void main(String[] args) {
		Zi zi = new Zi();
		zi.print(); //输出结果：3、3、3。
	}
}

class Fu {
int i = 1;
}

class Zi extends Fu {
	int i = 2;
	
	public void print() {
		int i = 3;
		
		System.out.println(i); //如果三个变量名都相同，根据相近原则取决i变量。
		System.out.println(i);
		System.out.println(i);
	}
}
  1. 如何让相同的变量名打印出出不同的值，实例：
class Demo {
	public static void main(String[] args) {
		Zi zi = new Zi();
		zi.print(); //输出结果：3、2、1.
	}
}

class Fu {
int i = 1;
}
class Zi extends Fu {
	int i = 2;
	public void print() {
		int i = 3;
	
		System.out.println(i);//输出本结构变量值。
		System.out.println(this.i);//this输出本类的变量值。
		System.out.println(super.i);//super输出父类的变量值。
	}
}
9. 在子父类继承中构造方法的关系？

1.子类在中的所有的构造方法的第一行，默认都有一个super()。

class Demo {
	public static void main(String[] args) {
		Zi zi = new Zi();
		System.out.pintln(zi.name);//null
	} 
}

class Fu {
	String name;
	public Fu() {}
}

class Zi extends Fu {

	public Zi() {
		//super();//调用父类的空参构造
	}
	public Zi(int age) {
		//super();//调用父类的空参构造
	}
	
}

2.子类中的所有的构造方法中，第一行要么是super(参数)，要么是this(参数)，他们不可以共存。
3.子类中所有的构造方法中至少有一个构造方法里面调用的是super(参数)。

class Demo {
	public static void main(String[] args) {
		Zi zi = new Zi();
	} 
}

class Fu {}
class Zi extends Fu {
	public Zi() {
		this("aaa"); //调用下面的方法。
	}
	
	public Zi(String name) {
		this(18);  //调用下面的方法。
	}
	
	public Zi(int age) {
		this("aaa", 18); //调用下面的方法。
	}
	
	public Zi(String name, int age) {
		//super();  //调用父类的方法。
	}
}
10. 在子父类继承中成员方法的关系？

在父类中有一个成员方法，在子类中有一个成员方法。

  1. 如果这两个方法的名字都不同的实例：
class Demo {
	public static void main(String[] args) {
		Zi zi = new Zi();
		zi.printFu();//输出结果：fu...
		zi.printZi();//输出结果：zi...
	}
}

class Fu {
	public void printFu() {
		System.out.println("fu...");
	}
}

class Zi extends Fu {
	public void printZi() {
		System.out.println("zi...");
	}
}
  1. 如果这两个方法的名字都相同的实例：
package 继承;

public class Dom2 {
	public static void main(String[] args) {
		msli li = new msli();
		li.println();
	}
}

//子类的方法的访问权限修饰符要大于等于父类的方法的访问权限修饰符,public > protected > 默认 > private。
class msliu
{
	public void println()
	{
		System.out.println("123");
	}
}

class msli extends msliu
{
	@Override  //证明该方法是重写方法。
	public void println()
	{
		System.out.println("456");
	}
}

//输出结果：456
11. 重写
  1. 什么是方法的重写(Override)呢？
  • 在子父类继承中，子类中出现与父类方法的声明完全一致的方法，就称为方法的重写(大致意思)。

2.方法的重写(Overide)和方法的重载(Overload)的区别？

  • 重载：在同一个类，两个方法的名字相同，参数列表不同。
  • 重写：在子父类继承中，子类中的方法和父类中方法是完全一致。

3.我们怎么证明该方法是重写方法呢？

  • 只需要在方法的声明上面加上@Override，参照以上实例。

4.重写的注意事项？

  • 1.子类不能重写父类中的私有的成员方法。
  • 2.子类的方法的访问权限修饰符要大于等于父类的方法的访问权限修饰符，参照以上实例。
  • 3.子类的方法的返回值类型可以和父类重写方法的返回值类不一致的， 但是有条件，父类方法的返回值类型是子类方法的返回值类型的父类。
//子类的方法的返回值类型可以和父类重写方法的返回值类不一致的,但是有条件，父类方法的返回值类型是子类方法的返回值类型的父类.

class msw
{
	public msu print()
	{
		return new msu();
	}
}
class mse extends msw
{
	public msn print()
	{
		return new msn();
	}
}

class msu{}
class msn extends msu{}
  • 4.静态方法只能重写静态方法。
三、面向对象三大特征 ——多态 1. 什么是多态？

是指一个对象在不同的时刻，表现出来的不同的状态。

2. 多态的前提条件？
  • 1.要有继承关系。
  • 2.要有方法的重写(可以没有)。
  • 3.要有父类引用指向子类对象。
3. 多态的代码体现？ 
class Fu {
	public void print() {}
}

class Zi extends Fu {//有继承关系
	public void print() {//有方法重写
	
	}
}

class Demo {
	public static void main(String[] args) {
		Fu fu = new Zi();//父类引用指向子类对象
	}
}
4. 多态间子父类之间成员变量的关系？

父类中有一个成员变量，子类中有一个成员变量。

  • 如果这两个变量的名字不同的话：
class Demo {
	public static void main(String[] args) {
		Fu fu = new Zi();
		System.out.println(fu.i);//1
		System.out.println(fu.j);//编译报错
	}
}

class Fu {
	int i = 1;
}

class Zi extends Fu {
	int j = 2;
}

分析： 通过结果分析，父类引用不能使用子类中特有的成员变量。

  • 如果这两个方法的名字都相同的话：
class Demo {
	public static void main(String[] args) {
		Fu fu = new Zi();
		System.out.println(fu.i);//1
		System.out.println(fu.i);//1
	}
}

class Fu {
int i = 1;
}
class Zi extends Fu {
	int i = 2;
}

分析： 父类引用只能使用自身带的成员变量，不能使用子类中成员变量。

口诀：多态，调用成员变量的时候，编译看左边，运行看左边。

5. 多态间子父类之间成员方法的关系？

父类中有一个成员方法，子类中有一个成员方法。

  • 如果这两个方法的名字都不同的话：
class Fu {
	public void printFu() {
		System.out.println("fu");
	}
}

class Zi extends Fu {
	public void printZi() {
		System.out.println("zi");
	}
}

class Demo {
	public static void main(String[] args) {
		Fu fu = new Zi();
		fu.printFu();//fu
		fu.printZi();//编译报错
	}
}

分析： 父类引用不能使用子类中特有的成员方法。

  • 如果这两个方法的名字都相同的话：
class Fu {
	public void print() {
		System.out.println("fu");
	}
}

class Zi extends Fu {
	public void print() {
		System.out.println("zi");
	}
}

class Demo {
	public static void main(String[] args) {
		Fu fu = new Zi();
		fu.print();//zi
		fu.print();//zi
	}
}

分析： 父类引用可以使用子类中重写父类的方法。

口诀：多态，调用成员方法，编译看左边，运行看右边。

6. 多态间子父类在之间静态成员的关系？ 6.1 静态成员变量： 
class Fu {
static int i = 1;
}

class Zi extends Fu {
	static int j = 2;
}

class Demo {
	public static void main(String[] args) {
		Fu fu = new Zi();
		System.out.println(fu.i);// 1
		System.out.println(fu.j); //编译报错
	}
}
6.2 静态成员方法： 
class Fu {
public static void print() {
		System.out.println("fu");
	}
}

class Zi extends Fu {
	public static void print() {
		System.out.println("zi");
	}
}

class Demo {
	public static void main(String[] args) {
		Fu fu = new Zi();
		fu.print();//fu
	}
}
6.3 总结：

多态，静态，成员变量和成员方法，编译看左边，运行看看左边。

7.多态的好处？
  1. 提高了代码的扩展性。
  2. 父类引用作为形式参数，子类对象作为实际参数。
public class Demo02 {
	public static void main(String[] args) {
		AnimalTool.print(new Cat());
		AnimalTool.print(new Dog());
		AnimalTool.print(new Pig());
	}
}

//动物工具类
class AnimalTool {
	public static void print(Animal animal) //Animal animal = new Dog/Cat/Pig(),重新定义
	{
		animal.eat(); //动物相应的值。
	}
}
class Animal {
	public void eat() {}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("吃骨头");
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("吃鱼");
	}
}

class Pig extends Animal {
	public void eat() {
		System.out.println("吃白菜");
	}
}
8.多态的弊端？

父类引用不能使用子类中特有的内容。

怎么解决？

  • 向下转型来解决这个问题。

何为转型？

  • 向上转型：Fu fu = new Zi();
  • 向下转换：Zi zi = (Zi)fu;

代码实例：

public class txt {
	public static void main(String[] args) {
		//向上转型
		Fu fu = new Zi();
		fu.eat();//吃肉
		
		//向下转型
		Zi zi = (Zi)fu;
		zi.play(); //玩游戏
		zi.eat();  //吃肉
		
		
	}
}


class Fu {
	public void eat() {
		System.out.println("吃饭");
	}
}

class Zi extends Fu {
	public void eat() {
		System.out.println("吃肉");
	}
	public void play() {
		System.out.println("玩游戏");
	}
}

总结：面向对象的三大特征已经讲完啦，欢迎小伙伴们前来评论呢？

欢迎分享，转载请注明来源：内存溢出

原文地址: https://outofmemory.cn/langs/737422.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-04-28
下一篇 2022-04-28

发表评论

登录后才能评论

评论列表（0条）

保存