用{}括起来的代码都是代码块。{}里面是他的作用域,在{}里面定义的方法和变量会在{}执行完成后被垃圾回收器回收(这一句是我猜的)。
局部代码块: 在main()里面,给变量限定它的生命周期。 给变量限定他的生命周期。
class Code{
//静态代码块:优先级第二高,第二执行
static{
int x = 1000 ;
System.out.println(x);
}
//成员位置
{
int x = 100 ;
System.out.println(x);
}
//构造方法
public Code() {
System.out.println("code");
}
//构造代码块
{
int y = 200 ;
System.out.println(y);
}
//有参构造
public Code(int a) {
System.out.println("code");
}
//静态代码块
static {
int y = 2000 ;
System.out.println(y);
}
}
public class CodeDemo {
public static void main(String[] args) {
//局部代码块:优先级最高最先执行
{
int x = 10 ;
System.out.println(x);
}
//局部代码块
{
int y = 20 ;
System.out.println(y);
}
//创建Code类的对象
Code code = new Code() ;
System.out.println("--------------------");
Code code2 = new Code() ;
System.out.println("--------------------");
Code code3 = new Code(100) ;
}
}
1000
2000
100
200
code
--------------------
100
200
code
--------------------
100
200
code
语法规定,对于继承不能存在多继承,只能单继承。但是可以支持多层继承。
子类继承父类都要默认访问父类的无参构造方法。原因:假如 数据没有初始化完毕,所以应该先让父类进行初始化,然后让子类进行初始化——分层初始化。
class Father{//这是一个父类
int money;
private int age;
private String name;
public void Fa() {
System.out.println("i am father");
}
private void Fa1() {
}
public Father() {
super();
}
public Father(int money, int age, String name) {
super();
this.money = money;
this.age = age;
this.name = name;
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Son extends Father{//这是一个子类
private String hoby ;
int num;
public void Aloha(){
System.out.println("i am son");
}
public Son() {
super();
}
public Son(int money, int age, String name,String hoby) {
super(money, age, name);
}
public String getHoby() {
return hoby;
}
public void setHoby(String hoby) {
this.hoby = hoby;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}
public class time8_50 {
public static void main(String[] args) {
Son s = new Son();
//通过对象s无法访问父类的私有成员变量和私有成员方法。
s.Fa();
s.setNum(10);
s.setHoby("pingpang");
System.out.println(s.getNum() + "-"+s.getHoby());
//创建父类的对象
Father f = new Father();
//创建完父类的对象后,子类对象可以调用父类的方法和非私有变量
s.setAge(80);
s.setMoney(210);
s.setName("zhangsan");
System.out.println(s.getName() + " " + s.getAge() + " " + s.getMoney() + " son:" + s.getNum() + " " + s.getHoby());
}
}
例如:
class Father1{
public int num = 100;
}
class Son1 extends Father1{
public int num = 10 ;
public void show() {
int num = 5;
System.out.println(num);//找寻顺序:子类方法中--->子类成员位置--->父类成员位置 到不了父类的方法中
System.out.println(this.num);//this可以在成员变量和局部变量同名的情况下指定成员变量
System.out.println(super.num);//super可以在成员变量和局部变量和父类中变量名相同的情况下直接指向父类中的变量。
}
}
public class time11_02 {
public static void main(String[] args) {
Son1 s =new Son1();
s.show();
}
}
3.必须有父类的引用指向子类的对象(向上转型)
class Fu{
int num = 10 ;
public void Num() {
System.out.println("父类的测试类");
}
}
class Zi extends Fu{
int num = 20 ;
public void Num() {//方法重写
System.out.println("子类的测试类");
}
}
public class Test1 {
public static void main(String[] args) {
Fu f = new Zi();//父类的引用指向子类的对象
System.out.println(f.num);
f.Num();
}
}
class Animal{
public void eat() {
System.out.println("吃");
}
public void sleep() {
System.out.println("睡");
}
}
class Dog extends Animal{
public void eat() {
System.out.println("狗吃屎");
}
public void sleep() {
System.out.println("狗睡觉");
}
}
class Cat extends Animal{
public void eat() {
System.out.println("猫吃猫粮");
}
public void sleep() {
System.out.println("猫睡觉");
}
}
class Pet extends Animal{
private Pet() {//不让创建Pet的对象
}
public static void PetTest(Animal a) {
a.eat();
a.sleep();
}
}
public class Test2 {
public static void main(String[] args) {
Animal c = new Cat();
Animal d = new Dog();
Pet.PetTest(c);
Pet.PetTest(d);
}
}
class Animal2{
public void eat() {
}
}
//猫类
class Cat2 extends Animal2 {
public void eat() {}
public void playGame() {}
}
//狗类:
class Dog2 extends Animal2{
public void eat() {}
public void lookDoor() {}
}
//测试类
public class DuoTaiDemo5 {
public static void main(String[] args) {
//内存中是猫
Animal a = new Cat() ;
//向下转型
//还原成猫
Cat c = (Cat)a;
//内存中变成了Dog
a = new Dog() ;
//还原成狗
Dog d = (Dog)a ;
Cat cc = (Cat)a ;//这句就会转换异常
}
}
class Person{
public void eat() {
System.out.println("吃饭...");
}
}
//南方人
class SourthPeople extends Person{
public void eat() {
System.out.println("南方人吃米饭...");
}
//特有功能
public void business() {
System.out.println("南方人爱经商...");
}
}
//北方人
class NorthPeople extends Person{
public void eat(){
System.out.println("北方人爱吃面...");
}
//特有功能
public void yanJiu() {
System.out.println("北方人爱钻研...");
}
}
//测试类
public class DuoTaiTest2 {
public static void main(String[] args) {
//多态:向上转型
Person p = new SourthPeople() ;//向上转型无法访问子类特有的东西
p.eat();
//向下转型
SourthPeople sp = (SourthPeople)p;//sp指向SourthPeople
sp.business();
System.out.println("-------");
//实际开中:是什么类,给什么了类的对象
SourthPeople sp2 = new SourthPeople() ;
sp2.eat();
sp2.business();
}
}
SourthPeople sp = (SourthPeople)p;//sp指向SourthPeople 需要特别特别理解!!!