Java - 基础代码 - 面向对象

package object;

public class object03 {
    static class Student{
        private String name;
        private int age;

        public void setAge(int sage) {
            if (sage > 0) {
                age = sage;
            }else {
                System.out.println("请输入正确年龄");
            }
        }

        public void setName(String sname) {
            name = sname;
        }

        public int getAge() {
            return age;
        }

        public String getName() {
            return name;
        }
        public void introduce(){
            System.out.println(name+age);
        }
    }
    public static void main(String[] args) {
        Student s = new Student();
        s.setAge(-12);
        s.setName("alex");
        s.introduce();
    }
}

package object;

class Person {
    public Person() {
        System.out.println("无参");
    }

    public Person(String a) {
        this();//只能在构造方法中使用，并且必须在第一行
        System.out.println("有参");
    }

    public Person(String a, int b) {
        System.out.println(a + b);
    }
    public static void hello(){
        System.out.println("静态方法可以不初始化直接调用");
    }
    static {
        System.out.println("类中的静态代码块执行了");
    }
}

// 无参构造，创建对象时会连同一并执行,命名与类名相同
// 构造方法重载
// 如果定义了有参构造方法最好再定义一个无参构造方法
// 构造方法一般都用public
public class object04 {
    static {
        System.out.println("main前的静态代码块执行了");
    }
    //    main前的静态代码块最先执行
    public static void main(String[] args) {
        Person.hello();
        Person p1 = new Person();
        Person p2 = new Person("?");
        Person p3 = new Person("number",2);
    }
}

package object;

class Outer{
    private int a = 1111111;
    public void test(){
        inner i = new inner();
        i.show();
    }
    class inner{
        void show(){
            System.out.println(a);
        }
    }
}
public class object05 {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.test();
//        main -> outer -> test -> inner -> show
    }
}

package object;

class Animal {
    String name;
    void shout(){
        System.out.println("动物叫");
    }
}
class giao extends Animal{
    public void printname(){
        System.out.println(name);
    }
}

public class object06 {
    public static void main(String[] args) {
        giao g = new giao();
        g.name = "giao";
        g.shout();
        g.printname();

    }
}
//只支持单继承 ,以下是错的
//class A{}
//class B{}
//class C extends A,B{}

//多个类可以继承一个父类
class boy{}
class shyboy extends boy{}
class cityboy extends boy{}

//也支持多层继承
class human{}
class man extends human{}
class goodman extends man{}

package object;
class Animal01{
    int a;
    void shout(){
        System.out.println("动物叫"+a);
    }
    public void super02(String a){
        System.out.println("子类使用super调用父类构造方法"+a);
    }
}
class giao01 extends Animal01{
    void shout(){
//        重写父类方法
//        子类重写父类方法时不能使用比父类严格的访问权限
        System.out.println("giao");
    }
    void super01(){
//        super关键字 访问父类的属性和方法
        super.a = 101010;
        super.shout();
//        调用父类有参构造方法
        super02("giao");
    }
}
public class object07 {
    public static void main(String[] args) {
        giao01 g = new giao01();
        g.shout();
        g.super01();
    }
}

package object;

//final
//修饰的类不能被继承
//修饰的方法不能被重写
//修饰的变量只能被赋值一次
public class object08 {
}

package object;

//抽象类 abstract
//允许抽象类 不写方法体
abstract class Animal02{
    abstract void shout();
//    shout后无方法体
}
class giao02 extends Animal02{
    @Override
    void shout() {
        System.out.println("giao");
    }

}
public class object09 {
    public static void main(String[] args) {
        giao02 g = new giao02();
        g.shout();
    }
}

package object;
//接口 interface
//接口中的方法都是抽象的不能实例化
//接口中的属性只能是常量
//当一个类实现接口时，如果时抽象类实现部分方法即可，否则实现所有方法
interface Animal03{
    String first = "一只动物在说";
//    默认修饰为 public static final
    void shout();
}
class giao03 implements Animal03{
    public void shout(){
        System.out.println(first+"giao");
    }
}
public class object10 {
    public static void main(String[] args) {
        giao03 g = new giao03();
        g.shout();
    }
}

package object;
class objectclass{

}
public class object11 {
    public static void main(String[] args) {
        objectclass c = new objectclass();
        objectclass cc = new objectclass();
        System.out.println(c.equals(cc));
        System.out.println(c.hashCode());
        System.out.println(c.toString());
        System.out.println(c.getClass());
    }
}

package object;


public class object12 {
    public static void main(String[] args) {
        try {
            int result = chufa(2,0);
            System.out.println(result);
        }catch (Exception e){
//            异常捕获
//            Exception 异常类型
//            e 异常对象
            System.out.println("异常："+e.getMessage());
            e.printStackTrace();
            return;
        }finally {
            System.out.println("finally执行了");
//            return 不会影响finally代码块的执行
        }
    }
    public static int chufa (int x,int y) throws Exception{
//        throw Exception 抛出异常,必须搭配异常处理，例上边的catch代码块
        int result = x / y;
        return result;
    }
}