Java内构造函数、关键字、权限修饰符、访问控制及面向对象的特性！

 

1, 构造函数(构造方法)
　　在使用 new 来创建一个对象的时候就是调用的这个类的一个构造方法(构造函数), 构造方法名与类同名, 并且没有返回值(没有返回值也不要写void)

　　空参的构造函数和有参数的构造函数

　　注释, 命名规则!!!!!!!!!!

2, 继承中的构造函数:
　　--子类的构造方法必须调用父类的构造方法
　　--super(), 调用父类的构造方法, this()调用本类中另外的构造方法

3, 关键字this, static, package和import语句
　　this:
　　　　--在类的方法定义中使用this关键字代表使用该方法的对象的引用

　　　　--当必须指出当前使用方法的对象是谁时要使用this

　　　　--有时this可以处理方法中成员变量和参数重名的情况

　　　　--this可以看作是一个变量, 它的值是当前对象的引用

　　static(不在堆里面也不在栈里面, 在数据区(data seg)):

　　　　--类名直接 . 出来的变量是静态变量, 每个类里面的静态变量只有一份, 是公用的(赋值后每个实例化的类都可使用)

　　　　--静态方法中不可访问非静态成员

　　　　--静态变量和静态方法不需要实例化

　　package:

　　　　便于管理大型软件系统中数目众多的类, 解决类名重名的现象

4, 访问控制, 权限修饰符(public private default protected)

        
　　puclic class 类名 {

　　　　private 类型 属性1;

　　　　private 类型 属性2;

　　　　set, get
　　}
5, 面向对象的三大特性: 封装, 继承, 多态
　　封装(...)

　　继承:

　　　　子类拥有父类的属性和方法

　　　　Object.finalize();调用这个方法来释放资源

　　多态((执行期间)动态绑定, 池绑定):

　　重载(overload):　　　　

　　　　　　　　方法重载是指方法名和方法的返回类型都相同,但方法参数不一样.参数不一样体现在参数个数和参数类型不一样

　　重写(overwrite / override):

　　　　将父类的方法重新定义　　　　

　　　　--重写的方法名.返回类型,参数类型和参数个数都要求和父类中的一样.这是重载和重写形式上的区别.

　　　　--在子类中可以根据需要从父类中集成来的方法进行重写

　　　　--重写方法必须和被重写的方法具有相同的方法名, 参数列表和返回类型

　　　　--重写方法不能使用比被重写方法更严格的访问权限

　　toString方法的重写

　　equals方法的重写

6,super, final关键字

　　super: 指向父类的引用

　　final的变量值不能改变

　　final的方法不能被重写

　　final的类不能被继承

7, 对象转型

　　--父类的引用可以指向其子类的对象

　　--父类的引用不可以访问其子类对象新增的成员(包括属性和方法)

　　--可以使用instanceof关键字来判断一下这个变量是不是这个类或者是这个类的子类的实例。

---

 

 

public class TestWrapper {
    public static void main(String[] args) {
        
        //包装类和java编程中常用的类Math
        
        String s = "12345";
        
        System.out.println("转换为数字的字符串: "+Integer.parseInt(s));
      //Math类
        //圆周率
        System.out.println(Math.PI);
        //自然对数
        System.out.println(Math.E);
        
        //三角函数
        //Math.sin(12.34);
        //Math.tan(12.34);
        //...
        //指数函数
        //Math.exp(12.34);
        //Math.log(12.34);
        //...
        
        //取整常用方法, 取整, 向上取整, 向下取整
        System.out.println(Math.rint(12.74));//跟谁近取谁
        System.out.println(Math.floor(12.74));//取最小整数
        System.out.println(Math.ceil(12.34));//取最大整数
        System.out.println(Math.round(12.34));//正儿八经的四舍五入, 返回long型整数
        System.out.println(Math.min(12.34, 23.45));//取两个数比较小的那个
        System.out.println(Math.max(12.34, 23.45));//取两个数比较大的那个
        System.out.println(Math.abs(-23));//取绝对值
                
    }
}

　　例题：定义一个圆的类, 定义一个点, 并计算这个点是否在圆的范围内

public class Point
{
    private double x;
    public double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return this.x;
    }
}

package com.maya.test;

public class Yuan {
    public double x;
    public double y;
    public double r;
    
    public Yuan(double x,double y,double r){
        this.x = x;
        this.y = y;
        this.r = r;
    }
    
    public void suan(Point p){
        double l = Math.abs(Math.sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y)));
        if(l>r){
            System.out.println("不在圆内");
        }else{
            System.out.println("在圆内");
        }
    }
}

package com.maya.test;

public class Main {
    public static void main(String[] args){
    Point n = new Point(3,4);
    Yuan s = new Yuan(2.2,3.3,5);
    s.suan(n);
    }
}

 

转载于:https://www.cnblogs.com/bekeyuan123/p/6863588.html