面向对象和接口的知识点，面试点，基础点。

面向对象（接口）

1，继承
this关键字（本类的成员），extends 关键字，super关键，继承是为了代码的复用性。
（1）概念：子类具有父类的一般特性，（属性+方法），以及自身的特殊的特性。
（2）方法的重写：子类中方法的名称，参数，返回类型，都有父类一样，但实现不同。（访问修饰符可以被放大不能被缩小）
（3）extends是继承父类中东西。
（4）super是调用父类中的东西。
格式：<1>super.属性/方法。 <2>super(参数)：调用父类的构造方法。（必须写在第一行）

面向对象(继承和代码块的面试题)(掌握)

A:看程序写结果
	class Student {
		static {
			System.out.println("Student 静态代码块");//3
		}
		
		{
			System.out.println("Student 构造代码块");
		}
		
		public Student() {
			System.out.println("Student 构造方法");
		}
	}

	class StudentDemo {
		static {
			System.out.println("StudentDemo的静态代码块");//1
		}
		
		public static void main(String[] args) {
			System.out.println("我是main方法");//2
			
			Student s1 = new Student();
			Student s2 = new Student();
		}
	}
	
A:案例演示
	看程序写结果1
	class Fu{
		public int num = 10;
		public Fu(){
			System.out.println("fu");
		}
	}
	class Zi extends Fu{
		public int num = 20;
		public Zi(){
			System.out.println("zi");
		}
		public void show(){
			int num = 30;
			System.out.println(num);//30
			System.out.println(this.num);//20
			System.out.println(super.num);//10
		}
	}
	class Test {
		public static void main(String[] args) {
			Zi z = new Zi();
			z.show();
		}
	}
	继承的弊端
	类的耦合性增强了。
	
	开发的原则：高内聚，低耦合。
	耦合：类与类的关系
	内聚：就是自己完成某件事情的能力

2，封装

将代码封装起来更有利于后期维护。
3，多态
一个事物，在不同情况的不同形态，比如（水，水蒸气，冰）
1.多态中的成员访问特点
a:成员变量
编译看左边，运行看左边。
b:构造方法
创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
c:成员方法
编译看左边，运行看右边。
d:静态方法
编译看左边，运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边的)
表现形式：父类对象=new 子类（）；对象.方法（）；

B:看下面程序是否有问题，如果没有，说出结果
		class A {
			public void show() {
				show2();
			}
			public void show2() {
				System.out.println("我");
			}
		}
		class B extends A {
			public void show2() {
				System.out.println("爱");
			}
		}
		class C extends B {
			public void show() {
				super.show();
			}
			public void show2() {
				System.out.println("你");
			}
		}
		public class DuoTaiTest4 {
			public static void main(String[] args) {
				A a = new B();
				a.show();
				
				B b = new C();
				b.show();
			}
		}
		答案-------->爱  你

4.final关键字
l修饰特点
修饰类: 被修饰类不能被继承
修饰方法: 被修饰的方法不能被重写
修饰变量: 被修饰的变量不能被重新赋值,因为这个量其实是一个常量
5.抽象类
（1）没有方法体{}，必须要使用abstract关键字子来修饰。
（2）不能直接调用，只能被重写才能使用。
（3）不能被实例化，只能继承。
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();

抽象类中的面试题)(掌握)

	A:面试题1
		一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
		答案: 可以 . 不能创建对象.
	B:面试题2
		abstract不能和哪些关键字共存?
			private    冲突
			final      冲突
			static     不能共存 无意义

6.接口
a:接口用关键字interface表示-------- 格式: interface - 接口名 {}
b:类实现接口用implements表示 -------- 格式: class- 类名 - implements - 接口名 {}
接口和抽象的区别：
（1）抽象类只能单继承，而接口是多实现。
（2）接口中的所有东西收必须是public的
（3）接口和抽象类中的方法都必须在实现类中实现。
（4）成员变量；只能是常量，并且是静态的。（简写了【public static final】数据类型常量名（大写））

**设计理念区别
		抽象类 	被继承体现的是：”is a”的关系。	抽象类中定义的是该继承体系的共性功能。
		接口 	被实现体现的是：”like a”的关系。	接口中定义的是该继承体系的扩展功能。**

面向对象和接口的知识点，面试点，基础点。

面向对象（接口）

猜你喜欢