方法
方法是用来完成功能的代码片段
方法是有方法头加方法体构成的即
//public 修饰符
//void 为空返回值类型，可以为 int 等类型
//hello方法名
//string a 传入的参数类型及名称
public void hello(string a){}
方法的重载
放的重载是方法名称相同，参数不同，返回值类型可以相同也可以不同
public class Demo {
public static void main(String[] args) {
student();
student(10);
}
public static void student() {
System.out.println("无参无返回值的student");
}
public static void student(int a) {
System.out.println("int的student");
}
}
递归
(1) 定义：自己调用自己
(2) 分为两部分：一部分调用自己，一部分用于终止，并且调用自己的时候在慢慢接近终止的条件
(3) 能不用递归就不用递归，除非基数少，因为调用的方法都会被压进栈里，栈并不大，不能够支持过多的方法，会卡
面向对象
面向过程是面对一个问题一步一步解决。
面向对象，简称OOP,是通过把问题进行分类，通过分类思维，对问题先分类，然后再对这些问题进行单独的解决，
Java就是一门面向对象的语言。
类
什么是类？什么是对象？
类是一种抽象的数据类型，是对某一类事物的描述
对象是抽象概念的实例
类是有属性和方法的
class Person { // 类名称首字母大写
String name ;
int age ;
public void tell() { // 没有static
System.out.println("姓名：" + name + "，年龄：" + age) ;
}
}
//对象是类的实例
类名称 对象名称 = new 类名称 () ;
封装
什么是封装？
属性是私有的，private。有get/set方法
是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流和交互。也就是说用户是无需知道对象内部的细节，但可以通过该对象对外的提供的接口来访问该对象。
权限
private：私有权限，只能在定义的类中访问，在其他类中创建的实例均无法访问
默认：同包可访问权限，在没有声明权限修饰符时为默认权限，允许在同包的其他类访问
protected：受保护权限，允许有继承关系的子类访问
public：公共权限，允许任何类访问
public class Dog {
// 私有化属性
private String name;
// 封装字段
public String getName() {
return name;
public void setName(String name) {
this.name = name;
}
}
继承
继承的本质是对某一批类的抽象，是类和类之间的一种关系
关键词是extends
class 父类 {
}
class 子类 extends父类 {
}
继承的特性：
1、子类拥有父类非private的属性和方法。
2、子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
3、子类可以用自己的方式实现父类的方法。
public abstract class Pet {
// 私有化属性
private String name;
private String sex;
// 封装字段
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
// 无参构造方法
public Pet() {
}
public Pet(String name, String sex) {
this.setName(name);
this.setSex(sex);
}
}
// 狗继承动物类
class Dog extends Pet {
private String color;
// 封装字段
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
// 无参构造方法
public Dog() {
}
// 有参构造方法
public Dog(String name, String sex, String color) {
// 传参到父类的构造方法,此处不能用this.name = name.....
super(name, sex);
// 调用setColor()方法给属性color赋值
this.setColor(color);
}
// 重写父类eat()方法
public void eat() {
// 方法体....
}
}
class Test {
public static void main(String[] args) {
String name = "dog1";
String sex = "男";
String color = "red";
// 实例化对象
Dog dog = new Dog();
dog.setName(name);
dog.setSex(sex);
// 通过有参构造函数实例化对象
Dog dog1 = new Dog("dogName", "man", "black");
// 调用eat()方法,此方法被重写了
dog1.eat();
}
}
super关键字
super短见字是调用父类方法，只能在类的方法和类的构造方法中
具体的super和this
方法重写
重写是方法的重写与属性无关
方法重写的现象：
父类有的方法，子类没有，子类直接继承使用
父类没有 ，子类特有 ，只能子类对象自己调用。
父类和子类都有某个方法 ，比如 show ，这就叫子类重写了父类的方法，简称方法重写，此时，子类对象调用的是子类中定义的方法。
方法重写需满足：
- 父类中的方法 和 子类中的方法
- 方法名必须一致
- 方法参数必须一致
4.子类的方法的访问修饰符不能缩小访问权限
5.返回值类型要一致（子类的返回值类型 也可以是 父类的返回值类型的子类）
class Dog extends Pet {
private String color;
// 封装字段
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
// 无参构造方法
public Dog() {
}
// 有参构造方法
public Dog(String name, String sex, String color) {
// 传参到父类的构造方法,此处不能用this.name = name.....
super(name, sex);
// 调用setColor()方法给属性color赋值
this.setColor(color);
}
// 重写父类eat()方法
public void eat() {
// 方法体....
}
}
多态
就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们可以通过相同的方式予以调用。同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
多态的前提：必须存在继承或者实现关系。
多态要注意的细节：
1. 多态情况下，子父类存在同名的成员变量时，访问的是父类的成员变量。
2. 多态情况下，子父类存在同名的非静态的成员函数时，访问的是子类的成员函数。
3. 多态情况下，子父类存在同名的静态的成员函数时，访问的是父类的成员函数。
4. 多态情况下，不能访问子类特有的成员。
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
abstract class Animal{
String name;
static String color="动物色";
public Animal(String name){
this.name=name;
}
public abstract void run();
public void eat(){
System.out.println("动物在吃东西");
}
}
//狗
class Mouse extends Animal{
static String color="狗色";
public Mouse(String name){
super(name);
}
public void run(){
System.out.println(name+"四条腿，灵活的走位");
}
public void eat(){
System.out.println("狗在吃东西");
}
public void dig(){//老鼠特有的方法
System.out.println("狗在打洞");
}
}
class Fish extends Animal{
public Fish(String name){
super(name);
}
public void run(){
System.out.println(name+"在海中快速的游行");
}
}
public class Demo4 {//多态
public static void main(String[] args) {
Animal a=new Mouse("狗" );
System.out.println(a.color);
a.eat();
}
}
抽象类和抽象方法
抽象类是指在普通类的结构里面增加抽象方法的组成部分。
抽象方法：只包含一个方法名，而没有方法体，使用abstract修饰
格式： {修饰符} abstract 返回类型 方法名（）；
修饰符（pubic protected private）
abstract class A{//定义一个抽象类
public void fun(){//普通方法
System.out.println("存在方法体的方法");
}
public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
}
抽象类必须使用abstract修饰符来修饰。抽象方法也必须使用abstract修饰符来修饰，不能有方法体。
抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例；
抽象类可以包含成员变量、方法（普通方法和抽象方法都可以）、构造器、初始化块、内部类（接口、枚举）5种成分。抽象类的构造器不能用于创建实例，主要是用于被其子类调用。抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。Abstract static不能同时修饰一个方法
接口
在java编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
在java中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象；修饰符public、abstract；接口的特性：
1）接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
2）接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
3）接口中的方法都是公有的。
4）编译时自动为接口里定义的方法添加public abstract修饰符
5）java接口里的成员变量只能是public static final共同修饰的，并且必须赋初值，可以不写public static final，编译的时候会自动添加。
903
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
