-
本质：以类的方式组织代码，以对象的方式组织（封装）数据
-
抽象
-
三大特性：-
-
封装
-
继承
-
多态
-
-
-
对象：是具体的事物
-
类：是抽象的，是对象的抽象
-
00方法回顾
//return：结束方法，返回一个结果 //break：跳出switch，或结束循环
方法的调用：
-
静态方法与非静态方法
-
静态方法(static)：属于类的。 调用方法：类名.方法名();
-
非静态方法：属于类中对象的 调用方法：对象名.方法名();
-
01类与对象的创建
Student类：
//属性：
String name;//默认值：null
int age;//默认值：0
//方法
public void study(){
System.out.println(this.name+"在学习");
}
对象的创建：
Student xiaoming=new Student();
02构造方法
-
和类名相同
-
无返回值
作用：
-
new本质是在调用构造方法
-
初始化对象的值
注意：定义有参构造之后，若想用无参构造，需显示定义一个无参的构造
生成构造函数快捷键：alt+insert
03创建对象的内存分析
Pet类：
public class Pet {
public String name;//默认值：null
public int age;//默认值：0
public void shout(){
System.out.println("叫了一声");
}
}
main()方法：
public static void main(String[] args) {
Pet dog=new Pet();
dog.name="旺财";
dog.age=3;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
Pet cat=new Pet();
}
04封装
程序设计追求高内聚，低耦合
属性私有，get/set
public class Student {
private String name;//名字
private int id;//学号
private char sex;//性别
private int age;
//提供可以操作属性的方法：get set
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//set中可以做一些安全性检测
public void setAge(int age) {
if (age > 120 || age < 0) {
System.out.println("年龄可能写错了");
} else {
this.age = age;
}
}
}
05继承
-
关键字：extends
-
extends意为扩展。子类是父类的扩展
-
JAVA中类只有单继承，无多继承
-
继承为类与类之间的一种关系。类和类指定的关系还有依赖、组合
-
子类与父类从意义上讲具有”is a“的关系(子类 is a 父类)
-
Object类：JAVA中，所有类，都默认继承Object类
Person类：
//JAVA中，所有类，都默认继承Object类
//Person 人 ：父类/基类
public class Person {
//private
//protected
//default
//public
private int money=10000000;
public void say(){
System.out.println("说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
Student类：
//Student is a 人：子类/派生类
//子类继承父类全部方法
public class Student extends Person{
//Ctrl+H
}
Teacher类：
public class Teacher extends Person{
}
main()方法：
public class Application {
public static void main(String[] args) {
Student student=new Student();
student.say();
}
}
super
-
super调用父类构造方法，必须在构造方法的第一行
-
super必须只能出现在子类的方法或构造方法中
-
super和this不能同时调用构造方法
对比 this：
-
代表对象不同：
-
this：代表调用者本身这个对象
-
super：代表父类对象的引用
-
-
前提：
-
this：没有继承也可以使用
-
super：只能在继承条件下才可以使用
-
-
构造方法：
-
this():本类的构造
-
super():父类的构造
-
方法的重写
重写：需要有继承关系，子类重写父类方法！
1. 方法名必须相同 1. 参数列表必须相同 1. 修饰符：范围可以扩大但不能缩小：public>protected>default>private 1. 抛出的异常：范围可以被缩小但不能扩大：ClassNotFoundException-->Exception（大）
重写，子类和父类必须要一致，方法体不同！
为什么要重写：父类的功能，子类不一定需要，或者不一定满足
B类：
public class B {
public void test(){
System.out.println("B:test()");
}
}
A类(继承B类)：
public class A extends B{
//@Override：重写
@Override//注解：有功能的注释！
public void test() {
System.out.println("A:test()");
}
}
main()方法：
A a=new A(); a.test(); //父类的引用指向子类 B b=new A();//子类重写父类方法 b.test();
运行结果：
A：test();
A：test();
06多态
-
多态是方法的多态，属性没有多态性
-
多态，是父类和子类，即必须有联系，否则 类型转换异常！ClassCastException！
-
多态存在条件：
-
有继承关系
-
子类重写父类方法
-
父类引用指向子类对象！ Father f=new Son()
-
不能重写的方法：
-
static 方法：静态方法属于类，不属于对象
-
final 方法：最终方法
-
private修饰的父类方法
eg：
Father f=new Son()
-
f能执行哪些方法，要看Father类中有哪些方法
-
f具体执行时，执行Son中的方法
07instanceof和类型转换
a instanceof A :判断a对象是否属于A类
-
把子类转换为父类：父类对象指向子类对象
-
把父类转换为子类，强制转换
person类：
public class Person {
}
Student类：
public class Student extends Person{
public void go(){
System.out.println("go");
}
}
main()方法：
public static void main(String[] args) {
Object object=new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
//子类转转换为父类
Person obj=new Student();
//obj.go();
//父类转换为子类
((Student)obj).go();
}
08static关键字详解
public class Student {
//匿名代码块
{
System.out.println("匿名代码块");
}
//静态代码块：只执行一次
static{
System.out.println("静态代码块");
}
//构造方法
public Student(){
System.out.println("构造方法");
}
private static int age;//静态变量 多线程
private double score;//非静态变量
public void run(){
}
public static void go(){
}
public static void main(String[] args) {
Student s1=new Student();
Student s2=new Student();
System.out.println(Student.age);
//System.out.println(Student.score);语法错误
System.out.println(s1.age);
System.out.println(s1.score);
Student.go();
//Student.run();语法错误
s1.run();
}
}
09抽象类
-
抽象类不能创建实例，即不能new抽象类
-
抽象类中可以写普通方法
-
抽象方法必须在抽象类中
Action类：
//abstract 抽象类:类 单继承
public abstract class Action {
//抽象方法：只有方法名，没有方法实现
public abstract void doSomething();
public void hello(){
System.out.println("hello");
}
}
A类：
public class A extends Action{
@Override
public void doSomething() {
}
10接口
对比：
-
普通类：只有具体实现
-
抽象类：具体实现和规范(抽象方法)都有
-
接口：只有规范！自己无法写方法。定义的是一组规则
声明类的关键字是class，声明接口的关键字是interface
接口作用
-
约束(即方法的声明)
-
2.定义一些方法，让不同人实现
-
默认 方法的前缀都是public abstract
-
默认 属性的前缀都是public static final
-
接口不能被实例化，接口中没有构造方法
-
implements可以实现多个接口
-
必须重写接口中的方法
11内部类
Outer类：
ublic class Outer {
private int id=10;
public void out(){
System.out.println("外部类的方法");
}
class Inner{
public void in(){
System.out.println("内部类方法");
}
//获得外部类私有属性
public void getId(){
System.out.println(id);
}
}
//方法中也可以写class
public void method(){
class Inner{
class InnerB{
}
}
}
}
//一个Java类中可以有多个class类，但只能有一个public class
class Apple{
public void eat(){
}
}
main()方法：
public static void main(String[] args) {
//new一个外部类
Outer outer=new Outer();
//通过外部类实例化内部类
Outer.Inner inner=outer.new Inner();
//匿名内部类
new Apple().eat();
}
扫一扫
386
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
