代码块
1.局部代码块(想到方法)
写在方法中
2.构造代码块
类中方法外 系统调用 每次构造对象都会调用 在构造之前就会调用
3.静态代码块
类中方法外 前面加static表示静态 写在构造代码快之前 也就是在构造代码块之前调用
随着类的加载而加载 只加载一次
4.同步代码块(多线程)
下面是构造代码快 静态代码快 构造方法之间的打印顺序
package com.lanou3g;
/*
* 打印顺序
*
*/
public class Demo02 {
static {
System.out.println("我是main方法的静态代码块");
}
public static void main(String[] args) {
System.out.println("我是main函数");
Test test1=new Test();
Test test2=new Test("晓峰");
}
}
class Test{
String name ;
public Test() {
System.out.println("我是Test类 无参构造方法");
}
public Test(String name) {
System.out.println("我是Test类 有参构造方法");
}
{
System.out.println("我是Test类 构造代码块");
}
static {
System.out.println("我是Test类 静态代码块");
}
}
打印结果
我是main方法的静态代码块
我是main函数
我是Test类 静态代码块
我是Test类 构造代码块
我是Test类 无参构造方法
我是Test类 构造代码块
我是Test类 有参构造方法
继承 1.继承可以传递2.继承的是属性和方法 但不是全部3.加强了类与类之间的联系
好处:减少代码量 提高效率 类与类之间的关系加强
继承
坏处:高内聚 :希望一个类中 提高 方法与方法 的联系 低耦合:希望类与类减少联系
使用继承时一定要遵循逻辑关系
继承的关键词 extends 写在类的后面 还要加上继承的父辈
举个例子说明一下
public class Demo03 {
public static void main(String[] args) {
// 穿件一个狗
Dog dog = new Dog();
dog.name = "饥渴";
dog.color = "黄色";
dog.sayHi();
dog.speak();
// 创建一个猫
Cat cat = new Cat();
cat.name = "汤姆";
cat.color = "黑色";
cat.sayHi();
}
}
class Animal {
String name;
String color;
public void sayHi() {
System.out.println(name + " " + color);
}
}
class Cat extends Animal {
public void speak() {
System.out.println("喵喵喵");
}
}
class Dog extends Animal {
public void speak() {
System.out.println("汪汪汪");
}
}
打印结果
饥渴 黄色
汪汪汪
汤姆 黑色
多层继承 A->B->C
继承是类和类之间的继承
public class Demo04 {
public static void main(String[] args) {
DemoA demoA = new DemoA();
// 直接打印对象的时候 相当于调用了Object类中 toString方法
System.out.println(demoA.toString());
}
}
//没有继承的类默认继承Object类
class DemoA extends Object {
String name;
public void sayHi() {
System.out.println(name);
}
}
class DemoB extends DemoA {
}
class DemoC extends DemoB {
String sex;
}
继承的构造方法:构造方法是不能被继承的
当子类创建对象时 为保证继承的完整性 系统默认会帮你调用 父类的无参构造方法
public class Demo05 {
public static void main(String[] args) {
Son son =new Son();
System.out.println("_______________");
Son son1=new Son("彭倩");
son1.sayHi();
}
}
class Father{
String name;
public Father() {
System.out.println("我是无参Father类的构造方法");
}
public Father(String name) {
System.out.println("我是有参Father类的构造方法");
}
public void sayHi() {
System.out.println(name);
}
}
class Son extends Father{
public Son() {
//系统帮你早构造方法的第一行 写了一句代码
//如果你不写系统会帮你写上
super();//调用父类的构造方法
System.out.println("我是son类的无参构造方法");
}
public Son(String name) {
super();//调用父类的构造方法
System.out.println("我是son类的有参构造方法");
}
}
打印结果
我是无参Father类的构造方法
我是son类的无参构造方法
_______________
我是无参Father类的构造方法
我是son类的有参构造方法
null
super 和this 指向
super指向类的对象 this:在子类中调用属性和方法 如果子类没有这个属性和方法时就去找父级找
没有找到的化就报错
public class Demo06 {
public static void main(String[] args) {
TestB testB= new TestB();
testB.print();
}
}
class TestA{
int num1=10;
int num2=20;
public void fun() {
System.out.println("我是父类的方法");
}
}
class TestB extends TestA{
int num2=30;
public void print() {
System.out.println(this.num1);
System.out.println(this.num2);
//直接调用父类的属性可以使用super关键词
System.out.println(super.num2);
super.fun();
}
}
打印结果
10
30
20
我是父类的方法
方法重写:条件:类与类之间 两者要有继承关系
方法的重写作用:对父级的方法的升级 写法和父类的写法一致
public class Demo08 {
public static void main(String[] args) {
TestD testD = new TestD();
testD.print();
Ios8 ios8 = new Ios8();
// 直接打印对象
// 希望把类的属性打印出来 ios8.siri();
System.out.println(ios8);
}
}
class TestC {
public void print() {
System.out.println("我是C类的print方法");
}
}
class TestD extends TestC {
public void print() {
System.out.println("我是D类的print方法");
super.print();
// 重写父类的方法时
// 调不调父类的方法根据你的需求而定
//
}
}
class Ios7 {
public void Siri() {
System.out.println("说英文");
}
}
class Ios8 extends Ios7 {
// 注释:标识这个方法是重写父类
@Override // 方法重写
public void Siri() {
super.Siri();
System.out.println("说中文");
}
// 这个方法一般用来输出本类中的属性
// tostring 方法的作用 输出属性;
@Override
public String toString() {
// 调用的是父类的方法
// 打印出默认 全类名@16进制哈hacode值
return "我就想看看属性";
}
}
打印结果
我是D类的print方法
我是C类的print方法
说英文
说中文
我就想看看属性