public class Demo01 {
/*
修饰符 返回值类型 方法名（...）{
//方法体
return 返回值；
}
*/
//return 结束方法，返回一个结果
public String sayHello(){
return "Hello";
}
public void hello(){
return;//返回值类型为void，返回值为空
}
public int max(int a,int b){
return a>b ? a:b;//三元运算符
}
public void readFile(String file) throws IOException{
}
}
//静态方法 static
public static void main(String[] args) {
//实例化这个类 new
//对象类型 对象名= 对象值
Student student=new Student();
student.say();
}
public void a(){
}
public class Demo03 {
public static void main(String[] args) {
//形式参数和实际参数的类型要对应
int add=Demo03.add(23,46);//实参
System.out.println(add);
}
public static int add(int a,int b){//形参
return a+b;
}
}
//值传递
public class Demo04 {
public static void main(String[] args) {
int a =1;
System.out.println(a);//1
Demo04.change(a);
System.out.println(a);//1
}
//返回值为空
public static void change(int a){
a=10;
}
}
//引用传递：对象 本质还是值传递
public class Demo05 {
public static void main(String[] args) {
Person person=new Person();
System.out.println(person.name);//null
Demo05.change(person);
System.out.println(person.name);//祝
}
public static void change(Person person){
//person是一个对象：指向--->Person person=new Person();这是一个具体的人，可以改变属性
person.name="祝";
}
}
//定义了一个Person类，有一个属性
class Person{
String name;
}
public class Person {
//一个类即使什么都不写，也会存在一个方法
//显示的定义构造器
String name;
//实例化初始值
//1.使用new关键字本质是在调用构造器
//2.用来初始化值
public Person(){
}
//有参构造:一旦定义了有参构造，无参构造就必须显式定义
public Person(String name){
this.name=name;
}
}
/*
public static void main(String[] args) {
//实例化了一个对象
Person person=new Person("zhuqq");
System.out.println(person.name);//zhuqq
}
构造器：
1.和类名相同
2.没有返回值
作用：
1.new本质在构造方法
2.初始化对象的值
注意点：
1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参构造
alt+insert:生成构造函数快捷键
*/
public class Pet {
public String name;
public int age;
//无参构造
public void shout(){
System.out.println("叫了一声");
}
}
public class Application {
public static void main(String[] args) {
Pet dog=new Pet();
dog.name="旺财";
dog.age=3;
dog.shout();
System.out.println(dog.age);
System.out.println(dog.name);
Pet cat=new Pet();
}
}
public class Student {
//属性私有
private String name;//名字
private int age;//年龄
private int id; //学号
private char sex; //性别
//提供一些可以操作这个属性的方法
//提供一些public的get,set方法
//get 获得这个数据
public String getName(){
return this.name;
}
//set 给这个数据设置值
public void setName(String name){
this.name=name;
}
public class Application {
public static void main(String[] args) {
Student s1=new Student();
s1.setName("zhu");
System.out.println(s1.getName());//zhu
}
}
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends的意思是“扩展”。子类是父类的扩展
Java中类只有单继承，没有多继承（可以通俗的理解为：一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子）
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖，组合，聚合等
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
子类和父类之间，从意义上讲应该具有“is a”的关系
object类：在Java中，所有的类都默认直接或间接继承object类
super
注意点：
super和this的区别：
? this：本身调用这个对象
? super：代表父类对象的引用
? this：没有继承也可以使用
? super：只有在继承条件下才可以使用
? this()：本类的构造
? super(): 父类的构造
方法重写：
需要有继承关系，子类重写父类的方法
方法名必须相同
参数列表必须相同
修饰符：范围可以扩大，但不能缩小
public-->protected-->default-->private
抛出的异常：范围可以被缩小，但不能扩大
子类和父类的方法要一致，方法体不同
为什么需要重写：
? 父类的功能，子类不一定需要，或者不一定满足
? Alt+Insert 重写快捷键
即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件：
注意：多态是方法的多态，属性没有多态性
//一个对象的实际类型是确定的
//new Student();
//new Person();
//可以指向的类型就不确定了:父类的引用指向子类
//Student 能调用的方法都是自己的或继承父类的
Student s1=new Student();
//Person 父类，可以指向子类，但不能调用子类独有的方法
Person s2=new Student();
Object s3=new Student();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
s2.run();//son
s1.run();//子类重写了父类的方法，执行子类的方法,son
s1.eat();//eat
}
public class Student extends Person {
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
public class Person {
public void run(){
System.out.println("跑起来");
}
}
instanceof
//object > String
// object > person >teacher
// object > person > student
Object object=new Student();
//System.out.println(X instanceof Y);能否编译通过，取决于X和Y之间是否存在父子关系
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false
System.out.println("================================================");
Person person=new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
// System.out.println(person instanceof String);编译报错
System.out.println("================================================");
Student student=new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);编译报错
// System.out.println(student instanceof String);编译报错
//类型之间的转化：父 子
//高 低
Person obj=new Student();
//student将这个对象转换为Student类型，就可以使用Student类型的方法了
Student student=(Student) obj;//由高到低，需要强转
student.go();
//也可以写成一句话：((Student) obj).go();
//子类转换为父类，可能会丢失自己本来的一些方法
Student student=new Student();
student.go();
Person person=new Student();
// person.go();报错
总结 :
多态注意事项
public class Student {
private static int age;//静态的变量
private double score;//非静态的变量
//非静态方法能调用静态方法里的所有东西
//静态方法只能调用静态方法里的东西,如果要用非静态方法里的东西，需要new一下
public void run(){
go();
}
public static void go(){
}
public static void main(String[] args) {
go();
Student s1=new Student();
s1.run();
}
}
public class Person {
//第二个执行，赋初始值
{
System.out.println("匿名代码块");
}
//第一个执行,且只执行一次
static {
System.out.println("静态代码块");
}
//第三个执行
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person=new Person();//静态代码块 匿名代码块 构造方法
System.out.println("======================");
Person person1=new Person();//匿名代码块 构造方法
}
}
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范,自己无法写方法
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是...则必须能...”的思想
接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如C++，Java等），就是因为设计模式所研究的，实际上就是如何合理的去抽象
声明类的关键字是class，声明接口的关键字是interface
public interface UserService {
//接口中的所有定义都是抽象的
//接口都需要有实现类
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
public interface TimeService {
void time();
}
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void time() {
}
}
接口的作用
内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对于B类来说就是外部类
成员内部类
public class Outer {
private int id;
public void out(){
System.out.println("外部类");
}
public class Inner{
public void in(){
System.out.println("内部类");
}
//获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}
import com.oop.demo10.Outer;
public class Application {
public static void main(String[] args) {
Outer outer=new Outer();
//通过外部类实例化内部类
Outer.Inner inner=outer.new Inner();
inner.in();//内部类
inner.getID();//0
静态内部类：加上static就是静态内部类
局部内部类
public class Outer {
//局部内部类
public void method(){
class Inner{
public void in(){}
}
}
}
匿名内部类
public class Test {
public static void main(String[] args) {
//匿名内部类，没有名字初始化类,不用将实例保存到变量中
new Apple().eat();
UserService userService= new UserService() {
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
在Exception分支中有一个重要的子类RunTimeException(运行时异常)
这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生
Error和Exception的区别：Error通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常
抛出异常
捕获异常
public class Test {
public static void main(String[] args) {
int a =1;
int b =0;
try {
//try监控区域
System.out.println(a/b);
}catch (ArithmeticException e){//捕获异常
System.out.println("出现异常");
}finally {//处理善后工作，可以不要
System.out.println("finally");
}
异常处理的五个关键字：try,catch,finally,throw,throws
原文：https://www.cnblogs.com/zqqzm0814/p/15076365.html