面向对象基础

  1. // 定义Person类
  2. class Person {
  3.     /*
  4.      * public公开，外界可以直接.属性就可以调用
  5.      * 暴露给外部可能会破坏封装性*/
  6.     public String name;
  7.     public int age;
  9. }
  11. public class Object {
  12.     public static void main(String[] args) {
  13.         // 实例化得到ming方法
  14.         Person ming = new Person();
  15.         // 方法.属性
  16.         ming.name = "少帅";
  17.         ming.age = 21;
  18.         System.out.println(ming.name);
  19.     }
  20. }

方法

  1. class Person{
  2.     private String name;
  3.     private int age;
  5.     public String getName(){
  6.         return this.name;
  7.     }
  9.     public void setName(String name){
  10.         if (name == null || name.isBlank()){  // isBlank()判断是不是空字符串
  11.             throw new IllegalArgumentException("invalid name");
  12.         }
  13.         this.name = name.strip();  // 去除两边的空格
  14.     }
  16.     public int getAge(){
  17.         return this.age;
  18.     }
  20.     public void setAge(int age){
  21.         if (age < 0|| age > 100){      // 满足条件抛出错误
  22.             throw new IllegalArgumentException("invalid age value");
  23.         }
  24.         this.age = age;   // this指当前实例ming
  25.     }
  26. }
  28. public class Object{
  29.     public static void main(String[] args) {
  30.         Person ming = new Person();
  31.         ming.setName(" 少帅 ");  // 设置name
  32.         ming.setAge(12);   // 设置age
  33.         System.out.println(ming.getName() + "," + ming.getAge());
  34.     }
  35. }
  37. 修饰符 方法返回类型 方法名(方法参数列表) {
  38.     若干方法语句;
  39.     return 方法返回值;
  40. }
  41. 方法返回值通过return语句实现，如果没有返回值，返回类型设置为void，可以省略return。
  43. private方法，外部代码无法调用，但是，内部方法可以调用它

方法参数

  1. class Person {
  2.     public void setNameAndAge(String name, int age) {
  3.         ...
  4.     }
  5. }
  6. // 调用setNameAndAge方法时必须传入两个参数（一个是name,另一个是age）
  8. class Group {
  9.     private String[] names;
  11.     public void setNames(String... names) {
  12.         this.names = names;
  13.     }
  14. }
  16. public class Object{
  17.     public static void main(String[] args) {
  18.         Person p = new Person();
  19.         String[] fullname = new String[]{"shuai","shenwo"};
  20.         p.setName(fullname);  // 传入fullname数组
  21.         System.out.println(p.getName());  // shuai shenwo
  22.         fullname[0] = "xiaoshuai";   // 编辑会改变值
  23.         System.out.println(p.getName());  // xiaoshuai shenwo
  24.     }
  25. }
  27. class Person{
  28.     private String[] name;
  30.     public String getName(){
  31.         return this.name[0] + " " + this.name[1];
  32.     }
  34.     public void setName(String[] name){
  35.         this.name = name;
  36.     }
  37. }
  41. public class Object{
  42.     public static void main(String[] args) {
  43.         Person p = new Person();
  44.         String bob = "Bob";
  45.         p.setName(bob);   // 传入bob变量
  46.         System.out.println(p.getName());  // Bob
  47.         bob = "Alice";   // 赋值不会改变bob的值
  48.         System.out.println(p.getName());  // Bob
  49.     }
  50. }
  52. class Person{
  53.     private String name;
  55.     public String getName(){
  56.         return this.name;
  57.     }
  59.     public void setName(String name) {
  60.         this.name = name;
  61.     }
  62. }

构造方法

  1. public class Object{
  2.     public static void main(String[] args) {
  3.         //Person p = new Person("小帅",21); // 实例化得到对象需要按要求传参，否则报错
  5.         //Person p = new Person("小王",26); // 输出传入的值
  6.         //Person p = new Person("小王"); // 输出传入的值
  7.         Person p = new Person(); // 输出传入的值
  8.         /*
  9.         * 第一种情况：如果调用new Person("小王",26);，会自动匹配到构造方法public Person(String, int)。
  10.         第二种情况：如果调用new Person(""小王"");，会自动匹配到构造方法public Person(String)。
  11.         第三种情况：如果调用new Person();，会自动匹配到构造方法public Person()。
  12.         * 第三种情况如果初始值赋值了，就显示初始值内容*/
  13.         System.out.println(p.getName());
  14.         System.out.println(p.getAge());
  15.     }
  16. }
  18. class Person {
  19.     private String name;  // 默认初始化为null
  20.     private int age;    // 默认初始化为0
  21.     //private String name="小帅";  // 可以在初始化赋值
  22.     //private int age=35;    // 可以在初始化赋值
  24.     // 初始化数据
  25.     public Person(String name,int age){
  26.         this.name = name;
  27.         this.age = age;
  28.     }
  30.     public Person(String name){
  31.         //this.name = name;
  32.         //this.age = 26;
  33.         this(name,18);
  34.     }
  36.     public Person(){
  37.         this("hfsdajhf");
  38.     }
  40.     public String getName(){
  41.         return this.name;
  42.     }
  44.     public int getAge(){
  45.         return this.age;
  46.     }
  47. }

方法重载

  1. /*
  2. 方法重载是指多个方法的方法名相同，但各自的参数不同；
  3. 注意：方法重载的返回值类型通常都是相同的。
  4. */
  6. public class Object {
  7.     public static void main(String[] args) {
  8.         String s = "Test string";
  9.         int n1 = s.indexOf('t');
  10.         int n2 = s.indexOf("st");
  11.         int n3 = s.indexOf("st", 4);  // s.indexOf(查找类型, 定起始位置)；
  12.         System.out.println(n1);  // 3
  13.         System.out.println(n2);  // 2
  14.         System.out.println(n3);  // 5
  15.     }
  16. }
  19. public class Object{
  20.     public static void main(String[] args) {
  21.         Person xiao = new Person();
  22.         Person wang = new Person();
  23.         xiao.setName("xiao wang");
  24.         wang.setName("xiao","wang");
  25.         System.out.println(xiao.getName());
  26.         System.out.println(wang.getName());
  27.     }
  28. }
  31. class Person{
  32.     private String name;
  34.     public String getName(){
  35.         return name;
  36.     }
  38.     public void setName(String name){
  39.         this.name = name;
  40.     }
  42.     public void setName(String name1,String name2){
  43.         this.name = name1 + " " +name2;
  44.     }
  45. }