代码块
在Java中,使用{}括起来的代码称为代码块
根据其位置和声明的不同,可以分为四种:
1.构造代码块:是在类中直接定义的,每次调用构造方法前执行,都会先执行构造代码块。
2.静态代码块:是在类中定义的,使用关键词 static 修饰的代码块,只加载一次,随着类的加载而加载,
在构造代码块之前执行
3.局部代码块:在方法内,局部位置,用于限定变量的生命周期
4.同步代码块:如果在代码块前加上 synchronized关键字,则此代码块就成为同步代码块。
举例:
public class Demo {
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类 有参构造方法
继承
继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为(并不是全部)。使用继承一定要符合逻辑。
public class Demo {
public static void main(String[] args) {
//创建一只猫
Cat cat = new Cat();
cat.name = "汤姆";
cat.color = "灰白色";
cat.say();
// 创建一只狗
Dog dog = new Dog();
dog.name = "日天";
dog.color = "棕色";
dog.say();
}
}
// 公共父类
class Animal{
String name;
String color;
public void say() {
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("汪汪汪");
}
}
注意:如果一个类没有写继承,那么这个类 默认继承 Object
public static void main(String[] args) {
DemoA a = new DemoA();
//当直接打印对象的时候
//相当于调用了 Object类中的 toString方法
System.out.println(a);
}
输出的是: 全类名@16进制的hashcode码
继承的特性
子类拥有父类非private的属性,方法。
子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如A类继承B类,B类继承C类,所以按照关系就是C类是B类的父类,B类是A类的父类,这是java继承区别于C++继承的一个特性。
提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系)。
继承中的构造方法:
注意:构造方法是不能继承的
当创建子类对象的时候 是为了保证继承的完整性,
不管你使用的是 无参还是有参构造,系统会帮你调用父类中的无参构造方法。
public class Demo05 {
public static void main(String[] args) {
Son son1 = new Son();
System.out.println("-------------");
Son son2 = new Son("彭于晏");
}
}
class Father{
String name;
public Father() {
System.out.println("我是Father类的无参构造方法");
}
public Father(String name) {
this.name = name;
System.out.println("我是Father类的有参构造方法");
}
public void say() {
System.out.println(name);
}
}
class Son extends Father{
public Son() {
// 系统帮你在 构造方法的第一行 写了一句代码
// 如果你不写 系统会帮你加上
super(); // 调用了父类的构造方法
System.out.println("我是son类的无参构造方法");
}
public Son(String name) {
super(); // 调用了父类的构造方法
System.out.println("我是son类的有参构造方法");
}
}
super 与 this 关键字
super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。
this关键字: 指向自己的引用。在子类可以调用子类的属性和方法,
当子类中没有这个属性或者方法的时候,就去父类中寻找 ,找到就用,没找到就报错
方法重载和方法重写
方法的重载(overload) 在一个类中进行
方法的重写(override) 至少两个类并且还有继承关系,相当于对父类的该方法进行升级
public class Demo {
public static void main(String[] args) {
TestD testD = new TestD();
testD.print();
}
}
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进制hashcode码
return "我就想看看属性";
}
}
关键字 final
1、final修饰的类不能被继承。
2、Sting就是一个被final修饰的类,我们只能用,不用继承。
3、final不仅可以修饰类,还可以修饰变量,被final修饰的变量就是一个常量,只能赋值一次。
4、修饰方法,方法不能被重写5、修饰引用数据类型 不能进行重新指向(地址不能改了) 对象中的属性不会影响修改
一般使用final的时候 会直接定义成静态常量,使用类名直接调用,常量命名规范 ,所有字母大写,多单词用下划线分开。
public static final int MAX_VALUE =10;