代码块
代码块
1.局部代码块
局部变量位置:方法中 和 方法声明中
作用:限定了局部变量的生命周期(作用域问题)
2.构造代码块
位置:在类中 方法外
调用顺序:在你创建对象的时候 如果你有构造代码块
系统会帮你先调用构造代码块 再调用构造方法
作用:如果每个对象都有相同方法去执行
可以在构造代码中调用(开发中机会没有这样的场景)
3.静态代码块(使用static来修饰)
位置:在类中方法外
特点:只加载一次 并且随着类的加载而加载
应用场景:加载驱动(JDBC 数据库连接)
4.同步代码块(多线程)
public class Demo01 {
static {
System.out.println("我是Demo01 静态代码块");
}
public static void main(String[] args) {
// 局部代码块
{
int num = 10;
System.out.println(num);
}
// 用午餐构造 创建一个Person对象
// 用有参 创建一个Person
//都调用 sayH方法
Person p= new Person();
}
}
class Person{
String name;
int age;
//
public Person() {
System.out.println("我是无参的构造方法");
}
public Person(String name,int age) {
this.name = name;
this.age = age;
System.out.println("我是有参的构造方法");
}
public void sayHi() {
System.out.println(name+"-----"+age);
}
// 构造代码块
{
System.out.println("我是构造代码块");
}
//静态代码块
static {
System.out.println("我是静态代码块");
}
}
输出结果
继承
继承特点:
1.减少重复的代码
2.减少你的工作量
3.可以把类中相同的代码抽取出来
继承不继承 要具体问题具体分析
什么时候使用继承?符合继承逻辑
举一个动物类的继承
class Animal{
String color;
int leg;
String name;
public void sayHi() {
System.out.println(color+"-----"+leg);
}
}
class Cat extends Animal{
}
class Dog extends Animal{
}
继承的规则
java中的继承
1.java中 值允许 单继承 不允许多继承(可以寄接口来实现多继承效果)
2.java中 允许 多层继承(属性方法会传递继承)
如果我想得到类中共有的方法和属性 使用哪个类
使用继承链最顶端的类
如果我想的到类中 特有的方法和属性 使用哪个类 使用最末端的类
如果一个类没有写继承那个类 实际上是继承了系统的类 Object类
Object类 是java 最顶端的类(基类)
多层继承的例子:
class DemoA extends Object{
String name;
public void sayHi() {
System.out.println(name);
}
}
class DemoB extends DemoA{
}
class DemoC extends DemoB{
}
继承中的构造方法
继承中的 构造方法
注意:构造方法是不能被继承的
1.为什么会打印爸爸无参构造方法?
要有儿子 先有爹 要初始化儿子类的对象 需要先去爸爸类中
调用构造方法
2.为什么儿子有参创建对象 也会打印爸爸无参构造方法?
下面的代码中会解释这个问题
class Father{
String name;
public void sayHi() {
System.out.println(name);
}
public Father(){
System.out.println("我是爸爸的 无参构造方法");
}
public Father(String name){
this.name = name;
System.out.println("我是爸爸的 有参构造方法");
}
}
class Son extends Father{
public Son() {
// 如果你没有调用 父类的构造方法
// name系痛会在这里帮你调用一下父类无参构造方法
super();
//调用父类无参构造方法
System.out.println("我是儿子 无参的构造方法");
}
public Son(String name) {
// 不管你有参无参的构造方法
// 只要你没有调用父类的构造方法 系统都会帮你调用
// 保证继承完整性
super();
this.name = name;
System.out.println("我是儿子 有参的构造方法");
}
}
继承中方法的同名变量调用的优先级
首先 说明下子类中 this super的区别
1. this 在 类中代表的是本类的对象(当前类的对象)
2.super 在类中代表的是 父类的对象
this.属性 可以调用到当前类的属性(现在当前类找这个属性)
(没找到的话 回去父类里找)
super.属性:可以调用到父类的属性
this.(); 调用本类的构造方法
super.(); 调用父类的构造方法
下面举一个 同名变量调用的例子
class Fruit{
int num1 = 10;
int num2 = 20;
}
class Apple extends Fruit{
int num2 = 30;
public void print() {
System.out.println(num1);
System.out.println(num2);//这里会输出 子类中的30 而不是20
System.out.println(super.num2);//这里会输出父类中的20
}
}
两个类继承中子类构造函数调用的情况
两个类继承关系
父类 没 有无参构造方法 ( 有 有参的构造方法)
子类的构造方法如何去写?
可以指定调用构造方法
class Car{
String name;
public Car(String name) {
this.name= name;
System.out.println("Car我是有参数的构造方法");
}
}
class Audi extends Car{
public Audi() {
// 只要你在构造方法的第一行 调用构造方法
// 这时系统将不再给你指定调用默认的无参构造方法
super("A8");
System.out.println("Audi 我是无参构造方法");
}
public Audi(String name) {
// 你不写父类构造 默认系统给你调用无参构造
// 你可以指定一个构造方法去调用
super(name);// 调用弗雷有参的构造方法
System.out.println("Audi 我是有参构造方法");
}
public void sayHi() {
System.out.println(name);
}
}
继承中的重写
当父类和子类有相同 成员方法时
class GlassCup extends Cup{
public void print() {
// Override和Overload有什么区别?
// Override 重写
// Overload 重载
// 当父类和子类方法完全一致时 叫做 方法重写
// super点 方法 可以调用父类的方法
// 重写的应用场景 当子类的方法 相对于父类的方法 有了升级
// 这是你可以使用方法的重写
// ios7 siri 只能英文
// ios8 siri 可以说英文 也能说中文
super.print();
System.out.println("我是玻璃杯");
}
}
class IOS7{
public void siri() {
System.out.println("我能说中文");
}
}
class IOS8 extends IOS7{
// 这个方法标识 重写父类方法
@Override
public void siri() {
// TODO Auto-generated method stub
// 这里调步调父类 要根据实际情况来写
super.siri();
System.out.println("功能升级 我能说中文了");
}
}
继承中 父类成员私有化 子类该如何修改
举个例子
父类是人 子类是老师
class Man{
// 注意:私有属性 是不能被继承的(不是很准确)
// 私有属性 可以继承下来 的 但是没有访问的权限
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//注意 私有属性是不能被继承的(不是很准确)
private String name;
private int age;
public Man() {
}
public Man(String name,int age) {
this.name=name;
this.age=age;
}
public void eat() {
System.out.println("吃饭");
}
}
class Teacher extends Man{
public Teacher() {
}
public Teacher(String name, int age) {
//调用父类有参构造
super(name,age);
}
public void teach() {
System.out.println(getName()+"教书");
}
//继承set get方法
// 能不能通过 set/get 取访问和修改属性呢
}
总结一下就是 父类中成员变量私有化之后
如果子类想修改就得通过 get的方法。
final关键字
final 关键字(绝育流)
1.修饰类 不能被继承
2.修饰变量 不能被修改
3.修饰方法 修饰方法时不能被重写
class Team{
// final 修饰的变量 相当于 常量(不能被修改的量)
// 命名规则 名字全部大写 多单词用下划线分开
public static final double PIPI = 3.14;
final int num; // 无效默认值
// final 赋值初值的两种方法
// 1,直接给初值
// 2. 从构造方法中赋值
public final void sayHi() {
System.out.println(PIPI);
}
}
class A extends Team{
public void sayHi() { //这里方法重写是报错的
}
}