�继承的实现

1, 继承的基本概念  : 扩展父类的功能

2,Java中使用extends关键字完成继承      class 子类 extends 父类{}

代码:

class Person{

private int age;

private String name;

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public void tel() {

// System.out.println("姓名"+getName()+" 年龄"+getAge());

}

}

class Student extends Person{

private int score;

public int getScore() {

return score;

}

public void setScore(int score) {

this.score = score;

}

public void want() {

System.out.println("成绩"+getScore()+"姓名"+getName()+" 年龄"+getAge());

}

}

public class ExtendsDemo01 {

public static void main(String[] args) {

Student stu = new Student();

stu.setAge(13);

stu.setName("zhangsan");

stu.setScore(100);

stu.tel();

继承的限制

1, 在Java中只允许单继承, 但可以多层集成

2, 子类不能直接访问父类的私有成员,  需要写setter和getter方法

子类对象的实例化

1, 在子类对象实例化之前,必须先调用父类中的构造方法, 之后调用子类构造方法

代码:

class Father{

private int age;

public Father(){

System.out.println("父类的构造方法");

}

}

class Son extends Father{

public Son(){

System.out.println("子类的构造方法");

}

}

public class ExtendsDemo03 {

public static void main(String[] args) {

Son son = new Son();

} //控制台打印结构: 先:父类的构造方法 再:子类的构造方法

}

Java方法重写与super关键字

方法的重写

1, 在继承中, 也存在着重写的概念, 其实就是子类定义了和父类同名的方法

2, 定义:  方法名称相同, 返回值类型相同, 参数也相同

3, 重写限制:  被子类重写的方法不能拥有比父类方法更加严格的访问权限

4, 访问权限: private < default < public

super关键字

1, super关键字: 强行调用父类的方法的执行

2, super不一定在重写中使用, 也可以表示那些方法时从父类中继承而来的

代码:

class A{

public void tell() {

System.out.println("我是父类的tell方法");

}

void say(){

System.out.println("我是父类的say方法");

}

}

class B extends A{

public void tell() {

super.tell();

System.out.println("我重写了父类的tell方法");

}

void say(){

super.say();

System.out.println("我重写了父类的say方法");

}

}

public class ExtendDemo04 {

public static void main(String[] args) {

// TODO Auto-generated method stub

B b = new B();

b.tell();

b.say();

}}

重写与重载的区别:

final关键字

1, final关键字在java中被称为完结器, 表示最终的意思

2, final能声明类, 方法, 属性: 1)使用final声明的类不能被继承  2)使用final声明的方法不能被重写  3)使用final声明的变量变成常量, 常量是不可以被修改的, 用final修饰的变量名称一般用大写字母

抽象类

1, 抽象类概念:  包含一个抽象方法的类就是抽象类

2, 抽象方法: 声明而未被实现的方法, 抽象方法必须使用abstract关键字声明

3, 抽象类被子类继承, 子类(如果不是抽象类)必须重新抽象类中的所有抽象方法

4, 定义格式:

5, 抽象类不能直接实例化, 要通过其子类进行实例化

代码:

abstract class ABs{

private int age;

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public abstract void tel();

}

class ABsDemo extends ABs{

@Override

public void tel() {

System.out.println("年龄为:"+getAge());

}

}

public class AbsDemo001 {

public static void main(String[] args) {

ABsDemo a = new ABsDemo();

a.setAge(20);

a.tel();

}}

接口:

1, 接口是Java中最重要的概念, 接口可以理解为一种特殊的类, 里面全部是由全局常量和公共的抽象方法所组成

2, 接口的格式: 

3, 接口的实现也必须通过子类, 使用关键字implements, 而且接口是可以多实现的

4, 一个子类可以同时继承抽象和实现接口

5, 一个接口不能继承一个抽象类,但是却可以通过exends关键字同时继承多个接口,实现接口的多继承

代码:

//接口类

interface inter1{

public static final int AGER = 100;

public abstract void tel();

}

interface inter2{

public abstract void say();

}

//抽象类

abstract class AbS{

public abstract void print();

}

//一个接口可以通过extends关键字同时继承多个接口, 实现接口的多继承

interface inter3 extends inter1, inter2{

}

// 一个子类可以同时继承抽象和实现接口

class A extends ABs implements inter1, inter2{

@Override

public void tel() {

System.out.println(AGER);

}

@Override

public void say() {

}

public void print() {

}

}

public class InterDemo01 {

public static void main(String[] args) {

A a = new A();

a.tel();

a.say();

a.print();

}

}

方法的定义

1, 方法就是一段可重复调用的代码段

2, 定义格式:   访问修饰符  返回值类型  方法名() { 方法主体 }

方法重载:  方法名称相同, 但是参数的类型和个数不同, 通过传递参数的个数和类型不同来完成不同的功能

代码:

public static void tell(int i, int j) {

System.out.println(i+j);

}

public static void tell(int i, int j, int n) {

System.out.println(i+j+n);

}

public static void main(String[] args) {

tell(10, 20);

tell(10, 20, 3);

}

类的定义, 声明及使用

1, class 类名称{ 属性   方法}

2, 声明一个类需要通过一个关键字class

类与对象的关系:

1, 类是对某一类事物的描述,是抽象的,概念上的意义, 对象是实际存在的该类事物的每一个个体, 也被称为实例

内存划分

面向对象编程思想

面向过程: 不去想做什么样子的盒子, 随机取工具制作

面向对象: 先想好做一个什么样的盒子, 再去找对应的工具去做

面向对象三大基本特征: 封装性: 对外包不可见   继承: 扩展类的功能   多态性: 方法的重载,对象的多态性

方法的递归调用

1, 递归调用是一种特殊的调用形式, 就是方法自己调用自己

代码:

public static void main(String[] args) {

// TODO Auto-generated method stub

add(100);

}

//  1+...+100的和

public static int  add(int num) {

if (num == 1) {//程序出口

return 1;

} else {

return num+add(num-1);

}}

Java关系运算

1, Java还有提供了对两个量之间的关系进行比较的运算, 成为关系运算

2, 关系运算的结果是true或false

案例: 键盘输入分数, 显示该分数是否及格:

代码: 

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.println("输入分数:");

int score = scanner.nextInt();

boolean isPass = score >= 60;

if (isPass) {

System.out.println(score + "及格" + isPass);

} else {

System.out.println(score + "不及格" + isPass);

}}

引用传递

代码:

class Ref1{

int temp = 10;

}

public class RefDemo01 {

public static void main(String[] args) {

Ref1 r1 = new Ref1();

r1.temp = 20;

System.out.println(r1.temp);//20

tell(r1);

System.out.println(r1.temp);//30

}

public static void tell(Ref1 r2) {

r2.temp = 30;

}}

this关键字

1, 表示类中的属性和调用方法

2,调用本类中的构造方法

3, 表示当前对象

代码:

class Teacher{

private String name;

private int age;

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;

}

//this.age 表示类中的属性和方法

public Teacher(String name, int age){

this();//调用本类中的构造方法, 必须放在第一行

this.age = age;

this.name = name;

}

public Teacher() {

System.out.println("无惨构造方法");

}

public void tel() {

System.out.println("姓名:"+this.getName() + "\n年龄"+ this.getAge());

}

}

public class ThisDemo01 {

public static void main(String[] args) {

Teacher t = new Teacher("zhang", 13);

t.tel();}}

代码: 表示当前对象

class Peopue{

public void tell() {

System.out.println(this);//com.jikexueyuan.thisdemo.Peopue@677327b6

}

}

public class ThisDemo02 {

public static void main(String[] args) {

Peopue p = new Peopue();

System.out.println(p);

p.tell();//com.jikexueyuan.thisdemo.Peopue@677327b6

}

}