黑马程序员_Java语言_面向对象__
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
08.01_面向对象(代码块的概述和分类)
- A:代码块概述
- 在Java中，使用{}括起来的代码被称为代码块。
- B:代码块分类
- 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程部分)。
- C:常见代码块的应用
- a:局部代码块
- 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
- b:构造代码块
- 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
- c:静态代码块
- 在类中方法外出现，加了static修饰
- 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
- a:局部代码块
08.02_面向对象(代码块的面试题)
- A:看程序写结果
class Student { static { System.out.println("Student 静态代码块"); } { System.out.println("Student 构造代码块"); } public Student() { System.out.println("Student 构造方法"); } } class StudentDemo { static { System.out.println("静态代码块,带你装逼带你飞"); } public static void main(String[] args) { System.out.println("我是main方法"); Student s1 = new Student(); Student s2 = new Student(); } }
结果:
静态代码块,带你装逼带你飞
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法08.03_面向对象(继承案例演示)
- A:继承的格式(extends)
- B:继承案例演示：
/*
以下程序重复太多
必须将共性抽取出一个类，特性不可以
*/
class Person
{
String name;
int age;
public void eat(){}
}
//定义老师类
class Teahcer extends Person
{
/*String name;
int age;
public void eat(){}*/
}
//定义学生类
class Student extends Person
{
/*
String name;
int age;
public void eat(){}*/
}
class ExtendsDemo
{
public static void main(String[] args)
{
System.out.println(new Student().age);
}
}
08.04_面向对象(继承的好处和弊端)
- A:继承的好处
- a:提高了代码的复用性
- b:提高了代码的维护性
- c:让类与类之间产生了关系，是多态的前提
B:继承的弊端
类的耦合性增强了。
开发的原则：高内聚，低耦合。
- 耦合：类与类的关系
- 内聚：就是自己完成某件事情的能力
08.05_面向对象(Java中类的继承特点)
- A:Java中类的继承特点
- a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹)
- 有些语言是支持多继承，格式：extends 类1,类2,…
- b:Java支持多层继承(继承体系)
- a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹)
- B:案例演示
- Java中类的继承特点
- 如果想用这个体系的所有功能用最底层的类创建对象
- 如果想看这个体系的共性功能,看最顶层的类
API
- Java中类的继承特点
08.06_面向对象(继承的注意事项和什么时候使用继承)
- A:继承的注意事项
- a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
- b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
- c:不要为了部分功能而去继承
B:什么时候使用继承
- 继承其实体现的是一种关系：”is a”。//是…的一种…
Person
Student
Teacher
水果
苹果
香蕉
橘子
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。- 继承其实体现的是一种关系：”is a”。//是…的一种…
08.07_面向对象(继承中成员变量的关系)
- A:案例演示
- a:不同名的变量
- b:同名的变量
/*
子类，父类中成员变量的特点
*/
class Fu
{
int i = 2;
}
class Zi extends Fu
{
int i = 3;
public void show(){
int i = 4;
System.out.println(this.i);
}
}
class ExtendsDemo1
{
public static void main(String[] args)
{
//创建子类对象
Zi z = new Zi();
//调用变量i
//System.out.println(z.i);
//调用子类方法 show
z.show();
}
}
08.08_面向对象(this和super的区别和应用)
- A:通过问题引出super
- 子类局部范围访问父类成员变量
- B:说说this和super的区别
C:this和super的使用
- a:调用成员变量
- this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
- super.成员变量 调用父类的成员变量
- b:调用构造方法
- this(…) 调用本类的构造方法
- super(…) 调用父类的构造方法
- c:调用成员方法
- this.成员方法 调用本类的成员方法,也可以调用父类的方法
- super.成员方法 调用父类的成员方法
- a:调用成员变量
D:案例演示
-
看程序写结果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);
System.out.println(this.num);
System.out.println(super.num);
}
}
class Test {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
fu
zi
30
20
10
08.09_面向对象(继承中构造方法的关系)
- A:案例演示
- 子类中所有的构造方法默认都会访问父类中空参数的构造方法
B:为什么呢?
- 因为子类会继承父类中的数据，可能还会使用父类的数据。
所以，子类初始化之前，一定要先完成父类数据的初始化。
其实：
- 每一个构造方法的第一条语句默认都是：super()在这里简单的提一句，Object类。Object在没有父类了。
08.10_面向对象(继承中构造方法的注意事项)
- A:案例演示
- 父类没有无参构造方法,子类怎么办?
- super解决
- this解决
- B:注意事项
- super(…)或者this(….)必须出现在第一条语句上
08.11_面向对象(继承中的面试题)
- A:案例演示
看程序写结果2 class Fu { static { System.out.println("静态代码块Fu"); } { System.out.println("构造代码块Fu"); } public Fu() { System.out.println("构造方法Fu"); } } class Zi extends Fu { static { System.out.println("静态代码块Zi"); } { System.out.println("构造代码块Zi"); } public Zi() { System.out.println("构造方法Zi"); } } Zi z = new Zi(); 请执行结果。
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi
08.12_面向对象(继承中成员方法关系)
- A:案例演示
- a:不同名的方法
- b:同名的方法
08.13_面向对象(方法重写概述及其应用)
- A:什么是方法重写
- B:方法重写的应用：
- 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。
- C:案例演示
- a:定义一个手机类。
/*
手机类和新式手机类。(加入好听的彩铃功能，基本功能由手机提供)
两个事物，
第一代手机，打电话，接电话功能(铃声，显示号码)
第二代手机，打电话，接电话功能(铃声，彩铃，显示号码，归属地)
解决办法1：修改原始代码，风险修改失败，修改后第一代手机不能用了
修改源代码，是一个灾难性工程
解决办法2： 沿袭上一代功能，扩展下一代功能，不修改源代码，第一代手机不受影响
面向对象 继承和重写方法，第二代手机，继承上一代手机功能，同时扩展自己的功能
*/
class Phone1
{
public void call(){
System.out.println("拨号打电话");
}
public void answer(){
System.out.println("铃声");
System.out.println("显示号码");
}
}
//定义第二代手机类，沿袭上一代手机(继承)，重写方法，扩展我自己
class Phone2 extends Phone1
{
//重写打电话功能
//没变化，不要自己写，使用父类
public void call(){
//调用父类方法
super.call();
}
//重写接电话功能
public void answer(){
//原有功能上，加入功能
super.answer();
System.out.println("彩铃");
System.out.println("显示归属地");
}
}
/*定义第三代手机，沿袭上一代手机，重写方法，扩展自己
class Phone3 extends Phone2
{
public void call(){
super.call();
}
public void answer(){
super.answer();
System.out.println("大头像");
}
}*/
class ExtendsTest
{
public static void main(String[] args)
{
Phone1 p1 = new Phone1();
p1.call();
p1.answer();
Phone2 p2 = new Phone2();
p2.call();
p2.answer();
//System.out.println("Hello World!");
}
}
08.14_面向对象(方法重写的注意事项)
A:方法重写注意事项
- a:父类中私有方法不能被重写
- 因为父类私有方法子类根本就无法继承
- b:子类重写父类方法时，访问权限不能更低
- 最好就一致
c:父类静态方法，子类也必须通过静态方法进行重写
- 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)
子类重写父类方法的时候，最好声明一模一样。
- a:父类中私有方法不能被重写
- B:案例演示
- 方法重写注意事项
/*
猫狗案例讲解
分析和实现
事物是猫和狗，
共性吃饭
特性，抓老鼠，看家
*/
//共性抽取
//eat方法，什么也没有，说不清楚，必须实际的动物才能说的清楚
//目的：子类应该继承并重写方法，实现自己的功能
class Animal
{
public void eat(){}
}
//猫类，吃饭，抓老鼠
class Cat extends Animal
{
public void eat(){
System.out.println("猫粮");
}
public void catchMouse(){
System.out.println("抓老鼠");
}
}
//狗类，吃饭，看家
class Dog extends Animal
{
public void eat(){
System.out.println("啃骨头");
}
public void lookHome(){
System.out.println("狗看家");
}
}
class ExtendsTest2
{
public static void main(String[] args)
{
/*Cat c = new Cat();
c.eat();
c.catchMouse();
Cat c1 = new Cat();
c1.eat();
c1.catchMouse();
Dog d = new Dog();
d.eat();
d.lookHome();
Dog d1 = new Dog();
d1.eat();
d1.lookHome();
以上程序，代码重复太多
将重复代码，封装到一个方法中，需要的话调用方法
*/
operator(new Cat());//0x01
operator(new Cat());
operator(new Dog());
}
//定义方法，负责猫的功能
public static void operator(Cat c){//0x01
c.eat();
c.catchMouse();
}
//定义方法，负责狗的功能
public static void operator(Dog d){
d.eat();
d.lookHome();
}
}
08.15_面向对象(方法重写的面试题的面试题)
A:方法重写的面试题
- Override和Overload的区别?Overload能改变返回值类型吗?
- overload可以改变返回值类型,只看参数列表
方法重写：子类中出现了和父类中方法声明一模一样的方法。
方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值无关。
子类对象调用方法的时候：
- 先找子类本身，再找父类。
08.16_面向对象(使用继承前的学生和老师案例)
- A:案例演示
- 使用继承前的学生和老师案例
08.17_面向对象(使用继承后的学生和老师案例)
- A:案例演示
- 使用继承后的学生和老师案例
/*
学生姓名，年龄
老师姓名，年龄
学生功能，学习功能
老师功能，上课功能
要求：共性抽取父类，父类成员私有，提高get set
在学生和老师的功能中，打印出自己的姓名和年龄
*/
//共性抽取，姓名，年龄
class Person
{
private String name;
private int age;
//提供get set间接访问成员变量
public void setName(String name){this.name=name;}
public String getName(){return this.name;}
public void setAge(int age){this.age=age;}
public int getAge(){return this.age;}
}
class Student extends Person
{
public void study(){
System.out.println("学生"+super.getName()
+"..."+super.getAge());
}
}
class Teacher extends Person
{
public void teacher(){
System.out.println("老师"+super.getName()
+"..."+super.getAge());
}
}
class ExtendsTest1
{
public static void main(String[] args)
{
//创建学生对象
Student s = new Student();
s.setName("张三");
s.setAge(16);
s.study();
//创建老师对象
Teacher t = new Teacher();
t.setName("李四");
t.setAge(28);
t.teacher();
//System.out.println("Hello World!");
}
}
08.18_面向对象(猫狗案例分析,实现及测试)
- A:猫狗案例分析
- B:案例演示
- 猫狗案例继承版
见上08.19_面向对象(final关键字修饰类,方法以及变量的特点)
- A:final概述
- B:final修饰特点
- 修饰类，类不能被继承
- 修饰变量，变量就变成了常量，只能被赋值一次
- 修饰方法，方法不能被重写
final修饰的成员变量--最终变量，只能赋值一次，终身不变，就是常量
final修饰成员变量，固定的数值，不是内存默认值
final修饰成员变量，可以在构造方法中赋值，但是不能在普通的方法中赋值
原因：构造方法是建立对象的过程，普通方法是对象已经建立完成了
日后在类中，如果定义静态的常量的使用
标准格式 public static final int A = 10;
public static final double PI = 3.14159265358979323846;- C:案例演示
- final修饰特点
/*
final关键字的使用
*/
class Fu
{
public void show(){
System.out.println("fu...show");
}
}
class Zi extends Fu
{
public void show(){}
}
//下面类，演示final修饰成员变量
class Final
{
final int i ;
/*Final(){
i = 3;
}
Final(int a){
i = 4;
}*/
public void a(){
i=2;
}
}
class FinalDemo
{
public static void main(String[] args)
{
//new Zi().show();
Final f = new Final();
// new Final(1);
System.out.println(f.i);
}
}
08.20_面向对象(final关键字修饰局部变量)
- A:案例演示
- 方法内部或者方法声明上都演示一下
/*
final修饰局部变量
面试中的题目
*/
class Zi
{
}
class FinalDemo1
{
public static void main(String[] args)
{
final int i ;
i = 3;
System.out.println(i);
method(9);
method(new Zi());
}
public static void method(final Zi z){
System.out.println(z);
}
public static void method(final int a){
System.out.println(a);
}
}
- 基本类型，是值不能被改变
- 引用类型，是地址值不能被改变
08.21_面向对象(final修饰变量的初始化时机)
- A:final修饰变量的初始化时机
- 在对象构造完毕前即可
- B:案例演示
- final修饰变量的初始化时机//见上