第一部分：代码块 （）第一节和第二节）
敲了半个小时的代码，发现同一一个错误 错误：仅当显示请求注释处理时才接受类名称。自己在文件加上后缀名.java就好了，不知道今天这个软件发什么神经了，所有的代码都不能保存为.java。后来发现了问题，在保存的时候，默认的文件名字是有.java后缀名字的，自己不知道怎么抽风了，把那个删掉了，以为下面的那个类型选择为java就可以，其实不然，需要名字后面加.java的后缀，类型也要选择为java
a:局部代码块
* 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
* b:构造代码块 (初始化块)
* 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
* c:静态代码块
* 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
* 一般用于加载驱动
code1；多看看这个代码的运行结果 也可以看看无参构造，有参构造是怎么运行的
class Demo1_code
{
public static void main(String[] args)
{
{
int x =10;
System.out.println(x);
}
student s1 = new student();
System.out.println("________");
student s2 = new student("张三",23);
}
static{
System.out.println("我是主方法类中的静态代码块");
}
}
class student
{
private String name;
private int age;
public student(){
System.out.println("我是空参构造");
}
public student(String name,int age){
this.name = name;
this.age = age;
System.out.println("我是有参构造");
}
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;
}
public void study(){
System.out.println(name+age);
}
{
System.out.println("我是构造代码块");
}
static{
System.out.println("我是静态代码块");
}
}
code2 这个也是看看代码块的执行结果
class Demo2_student
{
static{
System.out.println("Demo2的静态代码块");
}
public static void main(String[] args)
{
System.out.println("我是main方法");
student s1 = new student();
student s2 = new student();
}
}
class student
{
static{
System.out.println("静态代码块");
}
{
System.out.println("构造代码块");
}
public student(){
System.out.println("构造方法");
}
}第二部分 继承
继承比静态代码块重要多了，这块的代码也比较多
code1 :基本的一个继承案例
class Demo1_Extends
{
public static void main(String[] args)
{
//System.out.println("Hello World!");
Cat c = new Cat();
//c.cat();
c.eat();
c.sleep();
}
}
class Animal
{
String color;
int leg;
public void eat(){
System.out.println("eat");
}
public void sleep(){
System.out.println("sleep");
}
}
class Dog extends Animal
{
}
/*class Cat extends Anima
{
}*/
class Cat extends Animal
{
}code2 Java中单继承，不能多继承，支持多层继承
class Demo2_Extends
{
public static void main(String[] args)
{
DemoC c;
c = new DemoC();
c.show();
}
}
class DemoA
{
public void obb(){
System.out.println("A");
}
}
class DemoB extends DemoA
{
public void print(){
System.out.println("b");
}
}
class DemoC extends DemoB
{
public void show(){
System.out.println("c");
}
}code 3 A:继承的注意事项 放在课里就是第六节的视频
* a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
* b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
* c:不要为了部分功能而去继承
* 项目经理 姓名 工号 工资 奖金
* 程序员 姓名 工号 工资
* B:什么时候使用继承
* 继承其实体现的是一种关系："is a"。
class Demo3_Extends
{
public static void main(String[] args)
{
son s = new son();
s.show();
}
}
class father
{
private String name;
public void show(){
System.out.println("Hello World!");
}
}
class son extends father
{code 4 this和super的关系 对应的第七节
A:this和super都代表什么
* this:代表当前对象的引用,谁来调用我,我就代表谁
* super:代表当前对象父类的引用
* B:this和super的使用区别
* a:调用成员变量
* this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
* super.成员变量 调用父类的成员变量
* b:调用构造方法
* this(...) 调用本类的构造方法
* super(...) 调用父类的构造方法
* c:调用成员方法
* this.成员方法 调用本类的成员方法,也可以调用父类的方法
* super.成员方法 调用父类的成员方法
两个问题 自己一开始 没在子类中写方法那个框架，直接就是输出语句，这个要明白，类里面就是变量 方法，写什么东西要用方法 。第二个问题是，在写int num;num=20,这样分开写两条语句时候，出错了，这个要记住，不能这样写
class Demo4_Extends
{
public static void main(String[] args)
{
son s;
s = new son();
s.print();
}
}
class father
{
//int num1;
//num1 = 10;
//int num2;
//num2 = 20;
int num1 = 10;
int num2 = 20;
}
class son extends father
{
int num2 = 30;
//System.out.println(this.num1);
//System.out.println(this.num2);
//System.out.println(super.num2);
public void print(){
System.out.println(this.num1);
System.out.println(this.num2);
System.out.println(super.num2);
}
}code 5
A:案例演示
* 子类中所有的构造方法默认都会访问父类中空参数的构造方法
* B:为什么呢?
* 因为子类会继承父类中的数据，可能还会使用父类的数据。
* 所以，子类初始化之前，一定要先完成父类数据的初始化。
* 其实：
* 每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类
这个自己写的时候有个错误，就是自己又加了一个成员方法，为了调用构造方法，其实看看人家源代码，只要一创建对象，就可以调用构造方法，相当于 一创建对象，构造方法里的代码就会执行 无论你构造方法里是什么代码，如果是输出代码，那么就直接可以输出了
class Demo5_Extends
{
public static void main(String[] args)
{
son s;
s = new son();
//s.show();
}
}
class father
{
public father(){
System.out.println("父类的空参构造");
}
}
class son extends father
{
public son(){
super();
System.out.println("子类的空参构造");
}
/*public void show(){
System.out.println("Hello World!");
}*/
}code6 这个代码自己有点搞不明白，其实这个代码自己写的倒是挺对的，就是子类 父类 构造方法这些的相互结合，通过super这个关键字来实现的，在字类的无参构造方法中，可以通过super访问父类的无参构造方法，父类的有参构造方法。
class Demo6_Extends
{
public static void main(String[] args)
{
//System.out.println("Hello World!");
son s1 = new son();
System.out.println(s1.getname()+s1.getage());
}
}
class father
{
private String name;
private int age;
public father(){
System.out.println("父类的空参构造");
}
public father(String name,int age){
this.name = name;
this.age = age;
System.out.println("父类的有参构造");
}
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;
}
}
class son extends father
{
public son(){
super("杜喜彤",23);
//super();
//this("杜欣",21);
System.out.println("子类的空参构造");
//super("杜喜彤",23);
}
public son(String name,int age){
System.out.println("子类的有参构造");
}
}code7 这个是子类继承父类的方法，就是说可以super。方法名 调用父类的 同名字方法
class Demo7_Extends
{
public static void main(String[] args)
{
//System.out.println("Hello World!");
zi z;
z = new zi();
z.print();
}
}
class fu
{
public void print(){
System.out.println("fu print");
}
}
class zi extends fu
{
public void print(){
//super();
super.print();
System.out.println("zi print");
}
}code8 和上面那个代码类似 方法的重写
class Demo7_phone
{
public static void main(String[] args)
{
ios8 i;
i = new ios8();
i.call();
i.speak();
}
}
class ios7
{
public void call(){
System.out.println("Hello World!");
}
public void speak(){
System.out.println("说英文");
}
}
class ios8 extends ios7
{
public void speak(){
super.speak();
System.out.println("讲中文");
}
}code 9
A:方法重写注意事项
* a:父类中私有方法不能被重写
* 因为父类私有方法子类根本就无法继承
* b:子类重写父类方法时，访问权限不能更低
* 最好就一致
* c:父类静态方法，子类也必须通过静态方法进行重写
* 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)
方法重写和方法重载的区别
方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
* 方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。
class Demo8_双桨
{
public static void main(String[] args)
{
//zi z;
//z = new zi();
//zi.pao();
//zi.print();
//z.pao();
//z.print();
son s;
s = new son();
s.pao();
s.print();
}
}
class father
{
public void sing(){
System.out.println("唱红歌");
}
public void pao(){
System.out.println("泡妞");
}
public static void print(){
System.out.println("fu");
}
}
class son
{
public void pao(){
System.out.println("霸王强上弓");
}
public static void print(){
System.out.println("zi");
}
}TEST1 这个是学习this super关键字的一个代码 this修饰的是成员变量 super查询的是父类变量
class Test1_Extends
{
public static void main(String[] args)
{
zi z;
z = new zi();
z.show();
}
}
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);
}
}TEST2 这个代码是构造方法 代码块 和继承的结合
class Test2_Extends
{
public static void main(String[] args)
{
//System.out.println("Hello World!");
zi z;
z = new zi();
}
}
class fu
{
static{
System.out.println("父类静态代码块");
}
{
System.out.println("父类代码块");
}
public fu(){
System.out.println("父类无参构造");
}
}
class zi extends fu
{
static{
System.out.println("子类静态代码块");
}
{
System.out.println("子类代码块");
}
public zi(){
System.out.println("子类无参构造方法");
}
}
/*
1,jvm调用了main方法,main进栈
2,遇到Zi z = new Zi();会先将Fu.class和Zi.class分别加载进内存,再创建对象,当Fu.class加载进内存
父类的静态代码块会随着Fu.class一起加载,当Zi.class加载进内存,子类的静态代码块会随着Zi.class一起加载
第一个输出,静态代码块Fu,第二个输出静态代码块Zi
3,走Zi类的构造方法,因为java中是分层初始化的,先初始化父类,再初始化子类,所以先走的父类构造,但是在执行
父类构造时,发现父类有构造代码块,构造代码块是优先于构造方法执行的所以
第三个输出构造代码块Fu,第四个输出构造方法Fu
4,Fu类初始化结束,子类初始化,第五个输出的是构造代码块Zi,构造方法Zi
*/TEST3是没有的
TEST4 这个里面要注意，子类里的方法要想用name,必须是两个条件，第一个在有参构造里加上super(name,age)，第二个在使用的时候 this.getName()，要用这种方式调用，之前刚开始学方法的时候，直接就是name
class Test4_Person
{
public static void main(String[] args)
{
//System.out.println("Hello World!");
Student s;
s = new Student("杜欣",23);
s.study();
s.nianji();
}
}
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;
}
}
class Student extends Person
{
public Student(){}
public Student(String name,int age){
//super();
super(name,age);
}
public void study(){
System.out.println(this.getName());
}
public void nianji(){
System.out.println(this.getAge());
}
}TEST5 等到下次复习的时候再写一遍 。
最后一部分 final
A:final概述
final是最终的
* B:final修饰特点
* 修饰类，类不能被继承
* 修饰变量，变量就变成了常量，只能被赋值一次
* 修饰方法，方法不能被重写
* C:案例演示
* final修饰特点
code2 这个是final的另一个应用，
基本类型，是值不能被改变
* 引用类型，是地址值不能被改变,对象中的属性可以改变
class Demo2_final
{
public static void main(String[] args)
{
//
final Person p;
p = new Person("葛梦",22);
//p = new Person("杜欣",21); 这样不行的
p.setName("杜欣");
System.out.println(p.getName()+p.getAge());
}
}
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;
}
}code 3 这个讲解的是final初始化的时机，和内存图，创建对象那里有关