java的核心思想就是OOP(面向对象编程)
属性+方法变成一个类
面向过程&面向对象
面向过程：
线性逻辑，一步接一步来，步骤清晰
适合处理简单问题
面向对象：
分类解决问题，先将问题分为小类，然后线性解决
适合处理复杂问题，适合许多人协作完成的问题
初识面向对象面向对象变成的本质：以类的方法组织代码，以对象的组织(封装)数据
抽象的
三大特性：封装，继承，多态
方法回顾与加深
//void的默认返回值为空，故而可以用return;表示，或者直接不写return;
public void a(){
return;
}
public int b(int a,int b){
return a>b?a:b; //三元运算符(? :),如果a>b,返回a,否则返回b
}
public String c(){
return "dsjiadji";
}
break和return的区别
break用于结束循环
return用于结束方法，返回一个结果
静态方法与非静态方法
有static修饰符的叫静态方法
静态方法的使用
类名.方法名()
Dome1.a();
非静态方法的使用
先实例化这个类，通过new关键词
//对象类型 对象名字=对象的值 Dome1 dome1 = new Dome1(); Dome1.a();
static是和类一起加载的，而类是在实例化之后在存在的，所以静态方法中不能调用非静态方法
//static和类一起加载
public static void d(){
f();
}
//类实例化之后才存在，不能调用不存在的方法
public void f(){
}
对象的创建分析
类和对象的关系
类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但并不能代表某一个具体事物
对象代表一个具体的事物
一个项目应该只有一个main方法
package OOP;
//学生类
public class Student {
//属性
String name;
int age;
//方法
public void study(){
System.out.println(this.name+"在看书");
System.out.println(this.age+"生日刚过");
}
}
public class Index {
public static void main(String[] args) {
//类是抽象的，需要实例化才可以使用
//实例化后会返回自己的一个对象
Student student = new Student(); //student就是Student类的一个对象
Student student1 = new Student();
student.name="玉米";
student.age=17;
student1.name="肖华";
student1.age=16;
student.study();
student1.study();
}
}
构造器
类中的构造器也叫构造方法，实在进行创建对象的时候必须要调用的
构造器的特点：
必须和类名相同
必须没有返回值，也不能写void
public class Student {
//一个类即使什么都不写，也会存在一个方法(无参构造)
String name;
//无参构造显示定义
public Student(){
}
//有参构造，一旦定义有参构造，无参构造也必须显示定义
public Student(String name){
this.name=name;
}
public class Index {
public static void main(String[] args) {
Student student = new Student();
}
}
使用new关键字实例化对象时，本质是在调用构造器
构造器一般用来初始化值
默认初始值：
- 数字：0/0.0
- char：u0000
- boolean：false
- 引用类型：null
核心修饰符：private
该露的露，该藏的藏
程序设计要求“高内聚，低耦合”，类的内部数据操作细节自己完成，不允许外部干涉，仅暴露少量方法给外部使用
public class Student {
private String name;
private int age;
private char sex;
//alt+insert快速生成get set方法
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;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
if (sex!='男'||sex!='女'){ //安全性检查
System.out.println("输入错误");
}else {
this.sex = sex;
}
}
}
public class Index {
public static void main(String[] args) {
Student student = new Student();
student.setName("wdwiiah");
student.setAge(14);
System.out.println(student.getName());
System.out.println(student.getAge());
student.setSex('无');
}
}
封装的意义：
-
提高程序的安全性，保护数据
-
隐藏代码的实现细节
-
统一接口(get set)
-
提高系统的可维护性
核心词：extends
格式：public class 子类名 extends 父类名
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
继承是类和类之间的关系
在java中，所有的类都默认继承Object类
java中只有单继承，没有多继承
私有的东西无法被继承
final定义的父类不能被继承
public class Student extends Person {
public Student() {
//隐藏代码，调用了父类的无参构造
super(); //调用父类构造器，只能在子类构造器的第一行
System.out.println("子类构造器执行了");
}
}
public class Person {
public Person() {
System.out.println("父类构造器执行了");
}
}
super注意点：
- super调用父类的构造方法，必须在构造方法的第一个
- super只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
this和super的区别：
- 调用对象不同
this：本身调用者这个对象
super：调用父类对象
- 前提不同
this：没有继承也可以使用
super：只能在继承条件下使用
- 构造方法不同
this(); 本类的构造
super(); 父类的构造
方法的重写
重写都是方法的重写，和属性没有关系
重写与静态方法无关，只与非静态方法有关
子类重写父类的方法，方法名相同，方法体不同
前提：
-
有继承关系
-
方法名必须相同
-
参数列表必须相同
-
修饰符：范围可以扩大不能缩小(public>protected>default>private)
-
抛出的异常：范围可以缩小不能扩大
重写的意义：
- 父类的功能，子类不一定需要或者不一定满足
public class Person {
public void a(){
System.out.println("123456");
}
}
public class Student extends Person {
public void a(){
System.out.println("789456");
}
public void ss(){
System.out.println("4548");
}
}
public class Index {
public static void main(String[] args) {
//一个对象的实际类型是确定的，可以指向的应用类型不确定
Student s1 = new Student(); //能够调用的方法都是自己的或者继承父类的
Person s2 = new Student(); //可以指向子类，但是不能调用子类的方法
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
s1.a();
((Student) s2).ss(); //子类重写父类的方法，执行子类的方法
}
}
注意事项：
- 方法的多态，属性没有多态
- 必须有继承关系才可以转换
关键字：instanceof(判断两个类之间是否存在继承关系)
把子类转换为父类，向上转型，可直接转，不需要强制转换，但是可能会丢失一些方法
把父类转换为子类，向下转型，需要强制转换
方便方法的调用，减少重复的代码
抽象类和接口 抽象类关键字：abstract
抽象类的所有方法必须要由子类实现
抽象类不能new，只能靠子类去实现它，本身只是一个约束
抽象类里面可以写抽象方法和普通方法，但是有抽象方法的类必须是抽象类
抽象类中也存在构造器
//抽象类
public abstract class Absrt {
//抽象方法，只有方法的名字，没有方法的实现
public abstract void run();
}
public class Abserrt extends Absrt{
//抽象类的所有方法都要由继承它的子类来实现，除非他的子类也是抽象类
@Override
public void run() {
}
}
public class Index {
public static void main(String[] args) {
Abserrt absrt = new Abserrt();
}
}
存在的意义：提高开发效率
接口只有规范，没有方法
声明类的关键字：class
声明接口的关键字：interface
接口只负责定义，还需要有实现类写具体实现
public interface Abserrt{
//接口中所有的定义优势抽象的 public abstract
void add();
void delete();
void update();
void query();
}
public interface Time {
void time();
}
//类可以实现接口通过 implements 关键字
//实现了接口的类必须要重写接口中的方法
//可以利用接口实现多继承
public class AbserrtImpl implements Abserrt,Time{
@Override
public void add() {
}
@Override
public void delete() {
}
@Override
public void update() {
}
@Override
public void query() {
}
@Override
public void time() {
}
}
-
约束
-
定义一些方法，让不同的人实现
-
里面的方法都是 public static
-
里面的常量都是 public static final
-
接口不能实例化，接口中没有构造方法
内部类
类的嵌套
成员内部类
类在另一个类中
public class Domea {
private int a=11;
public void one(){
System.out.println("15478");
}
public class a1{
public void two(){
System.out.println("内部类");
}
//获得外部类的私有属性(也可以获得外部类的私有方法)
public void getA(){
System.out.println(a);
}
}
}
public class Index {
public static void main(String[] args) {
Domea domea = new Domea();
domea.one();
Domea.a1 a1 = domea.new a1(); //通过外部类来实例化内部类
a1.getA();
}
}
静态内部类
局部内部类
类在方法中
public class Domea {
// private int a=11;
public void one(){
class a1{
public void two(){
System.out.println("内部类");
}
//获得外部类的私有属性
public void getA(){
System.out.println(a);
}
}
}
}
匿名内部类
public class Index {
public static void main(String[] args) {
new Domea().two(); //没有初始化类名，不用将实例保存在变量中
}
}
