一.代码块
种类:
1.局部代码块:{代码}
书写位置:方法中
作用:限制变量的作用域
实例:(不经常这样用)
public class Kll {
public static void main(String[] args) {
{
int num = 10;
System.out.println("局部代码块");
}
}
2.构造代码块
书写位置:类中方法外
调用:1.系统在创建对象时,自动调用;2.在构造方法被调用之前,先被系统调用
作用:每个对象创建出来时,立即执行的某些方法,可以放在构造代码块中(实际上利用了特点:创建对象就会执行构造代码块)
代码例子:
public class Kll {
public static void main(String[] args) {
{
int num = 10;
System.out.println("局部代码块");
}
}
}
3.静态代码块(使用static修饰的代码块)
位置:类中方法外
调用特点:1.随着类的加载而调用(和对象的创建无关);2.只加载一次;3.系统加载类到方法区时自动调用
作用:加载驱动程序,只加载一次(JDBC)
代码例子:
public class Kll {
static {
System.out.println("main的静态代码块");
}
public static void main(String[] args) {
}
}
4.同步代码块 (多线程部分,后边会讲)
注意:
静态代码块优先于构造代码块执行
代码实例:
public class Kll {
public static void main(String[] args) {
/*{
int num = 10;
System.out.println("局部代码块");
}*/
Person p = new Person();
}
}
//暴力调试法(打印)
//小黄鸭调试法(调整代码逻辑)
//断点调试
class Person{
String name;
//无参构造方法
public Person() {
System.out.println("无参");
}
//有参构造方法
public Person(String name) {
this.name = name;
System.out.println("有参");
}
public void sayHi() {
System.out.println(name+" ");
}
//构造代码块
{
System.out.println("构造代码块");
}
//静态代码块
static {
System.out.println("静态代码块");
}
}
编译输出结果是:静态代码块 构造代码块 无参
二.继承
面向对象特征:
封装,继承,多态
继承的特点:
1.继承链
2.继承有传递性
3.继承行为和属性
4.建立类和类之间的关系(继承关系)
使用继承的前提条件:
注意:必须符合生活逻辑,才可以使用继承
继承的好处:
1.减少代码量
2.提高工作效率
3.增加代码的复用性
继承的弊端:
高内聚:指一个类的内部方法联系程度
低耦合:类与类之间尽量减少联系
设计模式基本上都是为了解耦(降低耦合度)
写法:关键字 extends
子类 extends 父类
public class Kll {
public static void main(String[] args) {
Cat cat = new Cat();
cat.name = "加菲猫";
cat.age = 1;
cat.sayHi();
cat.speak();
}
}
/*
* 动物类
* 姓名 年龄
* 猫类
* 姓名 年龄 喵喵喵
* 狗类
* 姓名 年龄 汪汪汪
*/
class Animal{
String name;
int age;
}
class Cat extends Animal{
public void speak() {
System.out.println("喵喵");
}
public void sayHi() {
System.out.println(name+" "+age);
}
}
class Dog extends Animal{
public void speak() {
System.out.println("汪汪");
}
}
判断是不是继承可以看看A是不是B,例如猫是不是动物,不是就不能继承
java中的继承是只允许单继承(类和类之间的关系),多继承体现在接口
java中允许多层继承(继承链)[一层一层继承下去]
比如要使用继承链中 特有的方法 使用哪儿个类好?
一般使用继承链中 末端的类
比如要使用继承链中 共有的方法 使用哪儿个类好?
一般使用继承链中 顶端的类
public class Kll{
public static void main(String[] args) {
//java中所有 如果没写继承哪儿个类,默认是继承Object类
//Object类是所有类的基类
//直接打印对象 实际上是调用了Object类中的toString()方法
//思考:toString()方法对你有什么用?
//可以用重写(后边会讲重写)来写介绍自己的方法,不用再写介绍自己的方法
KllA a = new KllA();
System.out.println(a);
}
}
class KllA{
String name;
public void sayHi() {
System.out.println(name);
}
}
class KllB extends KLlA{
}
class KllC extends KllB{
String gender;
}
三.继承中的构造方法
注意:构造方法是不能继承的
继承中的会自动调用(在未手写的情况下)父类的构造方法,是为了保证继承的完整性
代码实例:
public class Kll {
public static void main(String[] args) {
//创建son对象
//无参构造方法创建
//为什么会调用父类的无参构造方法?
//保证继承的完整性
//创建子类对象时,为了保证继承的完整性,会默认调用父类的无参构造方法
Son s1 = new Son();
Son s2 =new Son("王健林");
}
}
class Father{
String name;
//无参构造方法
public Father() {
super();//表示Father类的父类Object类的对象
System.out.println("Father类的无参构造方法");
}
//有参构造方法
public Father(String name) {
this.name = 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) {
System.out.println("son类的有参构造方法");
}
}
思考:如果父类中没有提供无参的构造方法,怎么办?
说明:该类中一定会有 有参的构造方法(使用super调用有参构造方法)
注意:以后写代码,必须提供一个无参构造方法(无参有参都写)
javaBean规范:
1.成员变量私有化
2.提供set/get方法
3.必须提供无参的构造方法
代码实例:
public class Kll {
}
class Car{
String name;
/*public Car() {
System.out.println("car 无参");
}*/
//有参构造方法
public Car(String name) {
System.out.println("Car 有参");
}
}
class Audi extends Car{
//无参构造方法
public Audi() {
//可以在构造方法的第一行调用有参的构造方法 来保证继承的完整性
//只要在子类中 调用父类的构造方法就行(不管有参还是无参)
super("哈哈");
System.out.println("Audi 无参");
}
//有参构造方法
public Audi(String name) {
super("哈哈");
System.out.println("Audi 有参");
}
}
四.关键字(this,super,final)
1.this和super
this:
类中表示 本类的对象
继承中 this属性系统会先从本类中找该属性,找到就输出,
没找到,就去父类中寻找,找到输出,都找不到会报错.
super:
在子类中 表示的是 父类的对象
super:也可以调用父类中的方法
代码例子:
public class Kll {
public static void main(String[] args) {
TestB b = new TestB();//创建一个TestB对象
b.fun();
}
}
class TestA{
int number1 = 10;
int number2 = 20;
}
class TestB extends TestA{
int number2 = 30;
public TestB(){
//根据就近原则打印的是本类的number1
System.out.println(number1);
}
public void fun() {
//打印的是本类的变量
System.out.println(this.number1);
System.out.println(this.number2);
//这里super表示父类的对象(即打印父类的number2)
System.out.println(super.number2);
}
}
2.final
关键字 final()
1.修饰变量 变量不能更改(相当于把变量变成了常量)
2.修饰方法 方法不能被重写
3.修饰类 该类不能被继承
代码实例:
public class Kll {
public static void main(String[] args) {
//final int a = 10;
//a = 15;赋值报错是因为该变量有final修饰,变为常量
// final 引用数据类型,不能修改地址(对象属性可以随意修改)
final Test t1 = new Test();
t1.name = "哈哈";
t1.name = "黑";
}
}
class Test3{
//声明静态常量
//命名规范:所有单词使用大写,多个单词使用下划线连接
public final int MAX_VALUE;//无效值(系统分配的初始值),所以会报错
String name;
//可以使用构造方法或者构造代码块进行赋值就不会报错
public Test3() {
MAX_VALUE = 10;
}
/*
{
MAX_VALUE = 10;
}
*/
public void fun1() {
}
}
class Test4 extends Test3{
public void fun() {
}
}
五.重写
方法的重载和重写
方法的重载(Overload)
前提:方法都在一个类,可以使用重载
当方法的功能相同,但是内部实现不同,可以使用重载
方法的重写(Override)
前提:类与类之间必须建立继承的关系
作用:相当于对原方法功能上的一个提升
写法:方法和父类完全一致,才是方法的重写
public class Kll {
public static void main(String[] args) {
//Test2 t1 = new Test2();
//t1.fun();
IOS8 ios8 = new IOS8();
ios8.Siri();
//意愿:直接输出对象时,希望可以把该对象的所有成员变量打印出来
System.out.println(ios8);
}
}
class Test1{
public void fun() {
System.out.println("Test1的fun方法");
}
}
class Test2 extends Test1{
//重写fun方法
public void fun() {
//可以在重写方法中,调用父类的原方法
//可以让功能进行升级
System.out.println("Test2的fun方法");
}
}
class IOS7{
String name = "kll";
String color = "亮红色";
//方法
public void Siri() {
System.out.println("English");
}
}
class IOS8 extends IOS7{
@Override //注解 标识下列方法 是重写父类的方法
public void Siri() {
super.Siri();
System.out.println("Chinese");
}
//重写Object类中的toString方法
//可以代替之前的介绍自己的方法 来输出对象的所有属性
@Override//注解 标识下列方法 是重写父类的方法
public String toString() {
return "name是:"+name+"\tcolor是:"+color;
}
}