代码块
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.加强了类与类之间的联系
好处：减少代码量 提高效率 类与类之间的关系加强
继承
坏处：高内聚 ：希望一个类中 提高 方法与方法 的联系 低耦合：希望类与类减少联系
扫描二维码关注公众号，回复：
919443 查看本文章
使用继承时一定要遵循逻辑关系
继承的关键词 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类的有参构造方法 nullsuper 和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方法 说英文 说中文 我就想看看属性