1.代码块
代码块
1.局部代码块(想到方法)
书写位置:方法中
作用:限制作用域
2.构造代码块
书写位置:类中 方法外
代码的执行顺序:
1.系统调用的
2.只要创建对象 就会调用
3.构造代码块在构造方法前被调用
作用:当有方法需要每一个对象都调用的时候 可以将这个方法 在构造代码块中调用
3.静态代码块
使用关键词static修饰的代码块
位置:类中 方法外
调用顺序:1.随着类的加载而加载 2.只加载一次 3.在构造代码块之前执行
应用场景: 加载驱动(数据库驱动----一个类)
4同步代码块(多线程)
举例:
static {
System.out.println("我是main方法的静态代码块");
}
public static void main(String[] args) {
System.out.println("我是main");
Test test1=new Test();
Test test2=new Test("zhang");
}
}
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.继承 建立 类和类之间的关系(让类和类更加紧密)
好处:1.减少代码量 2.提高工作效率 3.增强了类与类之间的关系
弊端:
高内聚:希望一个类中 方法与方法之间的联系加强
低耦合:希望类与类之间减少了联系
java中只允许单继承(类与类)(通过接口实现多继承)
java中允许多层继承(继承链) a->b->c
当你想只使用共有方法和属性时,使用哪个类的对象?
一般选择继承链的最顶端
当你想使用特有方法时,使用哪个类的对象?
一般选择继承链的最末端
如果一个类没有写继承,那么这个看类默认继承object类(基类).
继承中的构造方法(注意:构造方法时不能继承的)
当创建子类对象的时候,为了保证继承的完整性,
不管你在创建子类对象时使用的是无参还是有参构造,系统默认帮你调用父类中的无参构造方法.
3.super和this
super在子类中代表的是父类的对象
this关键字可以调用子类的属性和方法
(当子类中没有这个属性或方法时就去父类中寻找,找到就用,没找到就报错)
例1:
public static void main(String[] args) {
Son son =new Son();
System.out.println("--------");
Son son1=new Son("zhang");
}
}
class Father{
String name;
public Father() {
System.out.println("father无参");
}
public Father(String name) {
this.name=name;
System.out.println("father有参");
}
private 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有参
例2:
public static void main(String[] args) {
TestB testB=new TestB();
testB.print();
}
}
class TestA{
int num1=10;
int num2=20;
private 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);
}
打印结果:
10
30
20
例3:父类无参
public class Demo07 {
public static void main(String[] args) {
Audi audi=new Audi("sha");//有参测试
System.out.println("--------");
Audi audi2=new Audi();
}
}
class Car{
String name ;
//public Car() {
// System.out.println("car无参");
//}
//有参构造
public Car(String name) {
this.name=name;
System.out.println("car有参");
}
}
class Audi extends Car{
public Audi() {
//知道你在构造方法的第一行调用一下父类的构造方法(无参 有参都行)
super("双钻");
System.out.println("audi无参");
}
public Audi(String name) {
super("三钻");
this.name=name;
System.out.println("audi有参");
}
打印结果:
car有参
audi有参
--------
car有参
audi无参
4.方法重写
方法重载(overload)
一个类中进行
方法重写(override)
前提至少两个类 并且是继承关系
作用:对父类的该方法进行升级
public static void main(String[] args) {
IOS8 ios8=new IOS8();
System.out.println(ios8);
ios8.siri();
}
}
class TestC{
public void print() {
System.out.println("c类print方法");
}
}
class TestD extends TestC{
public void print() {
super.print();// 重写父类方法时,调不调用父类的方法根据需求而定
System.out.println("d类print方法");
}
}
class IOS7{
public void siri() {
System.out.println("说英文");
}
}
class IOS8 extends IOS7{
//注解 标识这个方法是重写父类
@Override
public void siri() {
super.siri();
System.out.println("说中文");
}
//这个方法一般用来输出本类中的属性
@Override
public String toString() {
//调用的是父类方法
//打印出来默认 全类名@16进制的hashcoad码
return "我就想看看属性";
}
打印结果:
我就想看看属性
说英文
说中文
5.final
1.修饰方法 方法不能被重写
2.修饰类 类不能被不继承
3.修饰变量 变量不能被修改
final修饰 引用数据类型 不能进行重新指向(地址不能修改)
对象中的属性不会影响修改
public static void main(String[] args) {
// final int num=20;
//num=20;
}
}
class TestE{
//堆内存分配默认值 是无效默认
//final修饰成员变量 需要赋初始值
赋初始值 三种方式
//一般使用final时 会直接定义成 静态常量
//使用了类名调用方便
常量命名规范 所有字母大写 多单词下划线分开
public static final int MAX_VALUE=10;//string host=localhost:8080/day05
private final void fun() {
}
public TestE() {
//构造方法中赋值
// num=10;
}
{
//构造代码块中赋值
//num=10;
}